Subversion Repositories SmartDukaan

Rev

Rev 6048 | Rev 6050 | 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 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
4763 rajveer 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
4579 rajveer 366 
    """
367 
    pass
368 
 
4910 phani.kuma 369 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 370 
    """
371 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 372 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 373 
 
374 
    Parameters:
375 
     - warehouseId
376 
     - providerId
377 
     - cod
4910 phani.kuma 378 
     - orderIds
4410 rajveer 379 
    """
380 
    pass
381 
 
5713 rajveer 382 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 383 
    """
384 
    Parameters:
385 
     - providerId
386 
     - orderIds
5713 rajveer 387 
     - awbs
5676 rajveer 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 392 
    """
4910 phani.kuma 393 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
394 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 395 
 
3064 chandransh 396 
    Parameters:
759 chandransh 397 
     - providerId
4910 phani.kuma 398 
     - pickupDetails
759 chandransh 399 
    """
400 
    pass
401 
 
4910 phani.kuma 402 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 403 
    """
404 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 405 
 
1113 chandransh 406 
    Parameters:
407 
     - providerId
408 
    """
409 
    pass
410 
 
1132 chandransh 411 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
412 
    """
413 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
414 
    the name of the receiver.
415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1132 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - deliveredOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 424 
    """
4910 phani.kuma 425 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 427 
 
1135 chandransh 428 
    Parameters:
429 
     - providerId
430 
     - returnedOrders
431 
    """
432 
    pass
433 
 
4910 phani.kuma 434 
  def getRTOrders(self, providerId):
435 
    """
436 
    Returns a list of orders that were returned by courier.
437 
 
438 
    Parameters:
439 
     - providerId
440 
    """
441 
    pass
442 
 
1246 chandransh 443 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
444 
    """
445 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 446 
 
1246 chandransh 447 
    Parameters:
448 
     - providerId
449 
     - undeliveredOrders
450 
    """
451 
    pass
452 
 
4910 phani.kuma 453 
  def getNonDeliveredOrdersbyCourier(self, providerId):
454 
    """
455 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
456 
 
457 
    Parameters:
458 
     - providerId
459 
    """
460 
    pass
461 
 
462 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
463 
    """
464 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
465 
 
466 
    Parameters:
467 
     - providerId
468 
     - local_connected_orders
469 
    """
470 
    pass
471 
 
472 
  def getOrdersNotLocalConnected(self, providerId):
473 
    """
474 
    Returns a list of orders that were picked up or shipped but pending local connection.
475 
 
476 
    Parameters:
477 
     - providerId
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - destination_city_reached_orders
488 
    """
489 
    pass
490 
 
491 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
492 
    """
493 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
494 
 
495 
    Parameters:
496 
     - providerId
497 
     - first_atdl_orders
498 
    """
499 
    pass
500 
 
1408 ankur.sing 501 
  def getUndeliveredOrders(self, providerId, warehouseId):
502 
    """
503 
    Returns the list of orders whose delivery time has passed but have not been
504 
    delivered yet for the given provider and warehouse. To get a complete list of
505 
    undelivered orders, pass them as -1.
506 
    Returns an empty list if no such orders exist.
3431 rajveer 507 
 
1408 ankur.sing 508 
    Parameters:
509 
     - providerId
510 
     - warehouseId
511 
    """
512 
    pass
513 
 
4783 phani.kuma 514 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
515 
    """
516 
    Returns the list of orders whose expected delivery date has passed but have not been
517 
    delivered yet.
518 
    Returns an empty list if no such orders exist.
519 
    """
520 
    pass
521 
 
2536 chandransh 522 
  def toggleDOAFlag(self, orderId):
523 
    """
524 
    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.
525 
    Returns the final flag status.
526 
    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 527 
 
2536 chandransh 528 
    Parameters:
529 
     - orderId
530 
    """
531 
    pass
1886 ankur.sing 532 
 
4712 rajveer 533 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
534 
    """
535 
    Parameters:
536 
     - orderId
537 
     - deliveryTimestamp
538 
     - receiver
539 
    """
540 
    pass
541 
 
5553 rajveer 542 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
543 
    """
544 
    Parameters:
545 
     - orderId
546 
     - deliveryTimestamp
547 
    """
548 
    pass
549 
 
4454 rajveer 550 
  def markOrderDoaRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
562 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4488 rajveer 570 
  def markOrderReturnRequestReceived(self, orderId):
571 
    """
572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
573 
 
574 
    Parameters:
575 
     - orderId
576 
    """
577 
    pass
578 
 
579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
580 
    """
581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
583 
 
584 
    Parameters:
585 
     - orderId
586 
     - isAuthorized
587 
    """
588 
    pass
589 
 
4579 rajveer 590 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 591 
    """
592 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 593 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
594 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 595 
    For any other status, it returns false.
596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2536 chandransh 598 
    Parameters:
599 
     - orderId
4579 rajveer 600 
     - providerId
2536 chandransh 601 
    """
602 
    pass
603 
 
4602 rajveer 604 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 605 
    """
4452 rajveer 606 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 607 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
608 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
609 
    	3. Returns true
2591 chandransh 610 
    If the order is in any other status, it returns false.
2536 chandransh 611 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 612 
 
2536 chandransh 613 
    Parameters:
614 
     - orderId
615 
     - pickupNumber
4602 rajveer 616 
     - providerId
2536 chandransh 617 
    """
618 
    pass
619 
 
2764 chandransh 620 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 623 
 
2764 chandransh 624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getDoasNotPickedUp(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 
 
4741 phani.kuma 639 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
640 
    """
641 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
642 
 
643 
    Parameters:
644 
     - providerId
645 
     - pickupDetails
646 
    """
647 
    pass
648 
 
4910 phani.kuma 649 
  def getReturnOrdersNotPickedUp(self, providerId):
650 
    """
651 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
652 
 
653 
    Parameters:
654 
     - providerId
655 
    """
656 
    pass
657 
 
4479 rajveer 658 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 659 
    """
4452 rajveer 660 
    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 661 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 662 
    If the order is in any other state, it returns false.
663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 664 
 
2591 chandransh 665 
    Parameters:
666 
     - orderId
4479 rajveer 667 
     - receiveCondition
2591 chandransh 668 
    """
669 
    pass
2536 chandransh 670 
 
2591 chandransh 671 
  def validateDoa(self, orderId, isValid):
672 
    """
4452 rajveer 673 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 674 
    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 675 
    If the order is in any other state, it returns false.
676 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 677 
 
2591 chandransh 678 
    Parameters:
679 
     - orderId
680 
     - isValid
681 
    """
682 
    pass
683 
 
4495 rajveer 684 
  def validateReturnProduct(self, orderId, isUsable):
685 
    """
686 
    Parameters:
687 
     - orderId
688 
     - isUsable
689 
    """
690 
    pass
691 
 
2616 chandransh 692 
  def reshipOrder(self, orderId):
693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 696 
    	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 697 
 
698 
    If the order is in DOA_CERT_VALID state, it does the following:
699 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
700 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 701 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 702 
 
2616 chandransh 703 
    Returns the id of the newly created order.
3431 rajveer 704 
 
2616 chandransh 705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 706 
 
2616 chandransh 707 
    Parameters:
708 
     - orderId
709 
    """
710 
    pass
2591 chandransh 711 
 
3226 chandransh 712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 713 
    """
4484 rajveer 714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 715 
    	1. Creates a refund request for batch processing.
716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 718 
 
2616 chandransh 719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
720 
    	1. Creates a refund request for batch processing.
3226 chandransh 721 
    	2. Cancels the reservation of the item in the warehouse.
722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 723 
 
3226 chandransh 724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
725 
    	1. Cancels the reservation of the item in the warehouse.
726 
    	2. Marks the current order as CANCELED.
727 
 
728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
729 
 
2616 chandransh 730 
    Returns True if it is successful, False otherwise.
3431 rajveer 731 
 
2616 chandransh 732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 733 
 
2616 chandransh 734 
    Parameters:
735 
     - orderId
3226 chandransh 736 
     - refundedBy
737 
     - reason
2616 chandransh 738 
    """
739 
    pass
740 
 
2690 chandransh 741 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
742 
    """
743 
    Get all return orders created between the from and to dates for the given warehouse.
744 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 745 
 
2690 chandransh 746 
    Parameters:
747 
     - warehouseId
748 
     - fromDate
749 
     - toDate
750 
    """
751 
    pass
2616 chandransh 752 
 
5481 phani.kuma 753 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
754 
    """
755 
    Get all return orders created between the from and to dates.
756 
 
757 
    Parameters:
758 
     - onlyNotProcessed
759 
     - fromDate
760 
     - toDate
761 
    """
762 
    pass
763 
 
2700 chandransh 764 
  def getReturnOrder(self, id):
765 
    """
766 
    Returns the ReturnOrder corresponding to the given id.
767 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 768 
 
2700 chandransh 769 
    Parameters:
770 
     - id
771 
    """
772 
    pass
773 
 
2690 chandransh 774 
  def processReturn(self, returnOrderId):
775 
    """
776 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 777 
 
2690 chandransh 778 
    Parameters:
779 
     - returnOrderId
780 
    """
781 
    pass
782 
 
3451 chandransh 783 
  def updateWeight(self, orderId, weight):
784 
    """
785 
    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 786 
 
3451 chandransh 787 
    Parameters:
788 
     - orderId
789 
     - weight
790 
    """
791 
    pass
792 
 
3469 chandransh 793 
  def changeItem(self, orderId, itemId):
794 
    """
795 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
796 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 797 
 
3469 chandransh 798 
    Parameters:
799 
     - orderId
800 
     - itemId
801 
    """
802 
    pass
803 
 
804 
  def shiftToWarehouse(self, orderId, warehouseId):
805 
    """
806 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
807 
 
808 
    Parameters:
809 
     - orderId
810 
     - warehouseId
811 
    """
812 
    pass
813 
 
4647 rajveer 814 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 815 
    """
816 
    Adds the given delay reason to the given order.
3986 chandransh 817 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 818 
    Raises an exception if no order with the given id can be found.
3469 chandransh 819 
 
3553 chandransh 820 
    Parameters:
821 
     - orderId
822 
     - delayReason
3986 chandransh 823 
     - furtherDelay
4647 rajveer 824 
     - delayReasonText
3553 chandransh 825 
    """
826 
    pass
827 
 
3956 chandransh 828 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
829 
    """
830 
    Marks the COD orders with given AWB nos. as having been processed.
831 
    Updates the captured amount for the corresponding payment.
3553 chandransh 832 
 
3956 chandransh 833 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
834 
    1. There is no order corresponding to an AWB number.
835 
    2. The captured amount for a payment exceeds the total payment.
836 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
837 
 
838 
    Parameters:
839 
     - collectedAmountMap
840 
     - xferBy
841 
     - xferTxnId
842 
     - xferDate
843 
    """
844 
    pass
845 
 
4008 mandeep.dh 846 
  def getTransactionsRequiringExtraProcessing(self, category):
847 
    """
4065 mandeep.dh 848 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 849 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 850 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 851 
 
4008 mandeep.dh 852 
    Parameters:
853 
     - category
854 
    """
855 
    pass
856 
 
857 
  def markTransactionAsProcessed(self, transactionId, category):
858 
    """
859 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 860 
    It essentially deletes the transaction id record for a particular
861 
    processing type category (if present) from DB.
862 
    This is currently used by CRM application.
4008 mandeep.dh 863 
 
864 
    Parameters:
865 
     - transactionId
866 
     - category
867 
    """
868 
    pass
869 
 
4018 chandransh 870 
  def getItemWiseRiskyOrdersCount(self, ):
871 
    """
872 
    Returns a map containing the number of risky orders keyed by item id. A risky order
873 
    is defined as one whose shipping date is about to expire.
874 
    """
875 
    pass
4008 mandeep.dh 876 
 
4295 varun.gupt 877 
  def getOrdersForItemIds(self, itemIds):
878 
    """
879 
    Returns a list of all orders which have items with given id
880 
 
881 
    Parameters:
882 
     - itemIds
883 
    """
884 
    pass
885 
 
4247 rajveer 886 
  def markOrderCancellationRequestReceived(self, orderId):
887 
    """
888 
    Mark order as cancellation request received. If customer sends request of cancellation of
889 
    a particular order, this method will be called. It will just change status of the order
890 
    depending on its current status. It also records the previous status, so that we can move
891 
    back to that status if cancellation request is denied.
4018 chandransh 892 
 
4247 rajveer 893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestConfirmed(self, orderId):
899 
    """
900 
    If we decide to to cancel order, CRM will call this method to move the status of order to
901 
    cancellation request confirmed. After this OM will be able to cancel the order.
902 
 
903 
    Parameters:
904 
     - orderId
905 
    """
906 
    pass
907 
 
908 
  def markOrderCancellationRequestDenied(self, orderId):
909 
    """
910 
    If we decide to not to cancel order, we will move the order ro previous status.
911 
 
912 
    Parameters:
913 
     - orderId
914 
    """
915 
    pass
916 
 
4258 rajveer 917 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 918 
    """
4258 rajveer 919 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
920 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 921 
 
922 
    Parameters:
4258 rajveer 923 
     - transactionId
4247 rajveer 924 
    """
925 
    pass
926 
 
4259 anupam.sin 927 
  def refundTransaction(self, transactionId, refundedBy, reason):
928 
    """
929 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
930 
    need to be cancelled
4247 rajveer 931 
 
4259 anupam.sin 932 
    Parameters:
933 
     - transactionId
934 
     - refundedBy
935 
     - reason
936 
    """
937 
    pass
938 
 
4324 mandeep.dh 939 
  def updateShipmentAddress(self, orderId, addressId):
940 
    """
941 
    Updates shipment address of an order. Delivery and shipping date estimates
942 
    etc. are also updated here.
943 
 
944 
    Throws TransactionServiceException in case address change is not
945 
    possible due to certain reasons such as new pincode in address is
946 
    not serviceable etc.
947 
 
948 
    Parameters:
949 
     - orderId
950 
     - addressId
951 
    """
952 
    pass
953 
 
4285 rajveer 954 
  def acceptOrdersForItemId(self, itemId, inventory):
955 
    """
956 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
957 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 958 
 
4285 rajveer 959 
    Parameters:
960 
     - itemId
961 
     - inventory
962 
    """
963 
    pass
964 
 
4369 rajveer 965 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 966 
    """
967 
    Parameters:
968 
     - vendorId
969 
     - itemId
970 
     - quantity
971 
     - estimate
4369 rajveer 972 
     - isReminder
4303 rajveer 973 
    """
974 
    pass
4285 rajveer 975 
 
4369 rajveer 976 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 977 
    """
978 
    Parameters:
979 
     - vendorId
980 
     - itemId
981 
     - quantity
982 
     - estimate
4369 rajveer 983 
     - isReminder
4303 rajveer 984 
    """
985 
    pass
986 
 
4369 rajveer 987 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 988 
    """
989 
    Parameters:
990 
     - vendorId
991 
     - itemId
992 
     - quantity
993 
     - estimate
4369 rajveer 994 
     - isReminder
4303 rajveer 995 
    """
996 
    pass
997 
 
4369 rajveer 998 
  def markOrdersAsTimeout(self, vendorId):
999 
    """
1000 
    Parameters:
1001 
     - vendorId
1002 
    """
1003 
    pass
4303 rajveer 1004 
 
4662 rajveer 1005 
  def markOrderAsLostInTransit(self, orderId):
1006 
    """
1007 
    Mark order as LOST_IN_TRANSIT
1008 
 
1009 
    Parameters:
1010 
     - orderId
1011 
    """
1012 
    pass
1013 
 
4386 anupam.sin 1014 
  def getOrderForAwb(self, awb):
1015 
    """
1016 
    Returns the order corresponding to an AWB number
4369 rajveer 1017 
 
4386 anupam.sin 1018 
    Parameters:
1019 
     - awb
1020 
    """
1021 
    pass
1022 
 
4910 phani.kuma 1023 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1024 
    """
4910 phani.kuma 1025 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1026 
 
4506 phani.kuma 1027 
    Parameters:
1028 
     - logistics_provider_id
4910 phani.kuma 1029 
     - order_status_list
4506 phani.kuma 1030 
    """
1031 
    pass
1032 
 
4600 varun.gupt 1033 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1034 
    """
1035 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1036 
 
4600 varun.gupt 1037 
    Parameters:
1038 
     - vendorId
1039 
     - billingDateFrom
1040 
     - billingDateTo
1041 
    """
1042 
    pass
1043 
 
4607 rajveer 1044 
  def getSlippedSippingDateOrders(self, ):
1045 
    pass
1046 
 
4709 rajveer 1047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1048 
    """
1049 
    Parameters:
1050 
     - cancelDateFrom
1051 
     - cancelDateTo
1052 
    """
1053 
    pass
1054 
 
4600 varun.gupt 1055 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1056 
    """
1057 
    Parameters:
1058 
     - mapAWBAndAmount
1059 
    """
1060 
    pass
1061 
 
4905 varun.gupt 1062 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1063 
    """
1064 
    Parameters:
1065 
     - settlementDate
1066 
     - paymentGatewayId
4905 varun.gupt 1067 
     - referenceId
4600 varun.gupt 1068 
     - serviceTax
1069 
     - otherCharges
1070 
     - netCollection
1071 
    """
1072 
    pass
1073 
 
1074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
     - settlementDate
1079 
     - transactionDateFrom
1080 
     - transactionDateTo
1081 
     - amount
1082 
    """
1083 
    pass
1084 
 
5386 phani.kuma 1085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1086 
    """
1087 
    Parameters:
5189 varun.gupt 1088 
     - referenceId
1089 
     - isRefund
4600 varun.gupt 1090 
    """
1091 
    pass
1092 
 
5386 phani.kuma 1093 
  def getSettlementForCod(self, orderId, isRefund):
1094 
    """
1095 
    Parameters:
1096 
     - orderId
1097 
     - isRefund
1098 
    """
1099 
    pass
1100 
 
4600 varun.gupt 1101 
  def getEBSSettlementSummaries(self, ):
1102 
    pass
1103 
 
1104 
  def markEBSSettlementUploaded(self, settlementId):
1105 
    """
1106 
    Parameters:
1107 
     - settlementId
1108 
    """
1109 
    pass
1110 
 
1111 
  def getEBSSettlementDate(self, settlementId):
1112 
    """
1113 
    Parameters:
1114 
     - settlementId
1115 
    """
1116 
    pass
1117 
 
4715 varun.gupt 1118 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1119 
    """
1120 
    Parameters:
1121 
     - settlementDateFrom
1122 
     - settlementDateTo
1123 
     - isRefund
1124 
    """
1125 
    pass
4600 varun.gupt 1126 
 
4715 varun.gupt 1127 
  def getReshippedOrderIds(self, orderIds):
1128 
    """
1129 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1130 
 
1131 
    Parameters:
1132 
     - orderIds
1133 
    """
1134 
    pass
1135 
 
5481 phani.kuma 1136 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1137 
    """
1138 
    Parameters:
1139 
     - vendorId
5481 phani.kuma 1140 
     - onlyVendorNotPaid
1141 
     - billingDateFrom
1142 
     - billingDateTo
4875 varun.gupt 1143 
    """
1144 
    pass
4757 mandeep.dh 1145 
 
5031 varun.gupt 1146 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1147 
    """
1148 
    Parameters:
1149 
     - startDate
1150 
     - endDate
1151 
    """
1152 
    pass
4875 varun.gupt 1153 
 
5067 varun.gupt 1154 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1155 
    """
1156 
    Parameters:
1157 
     - status
1158 
     - startDatetime
1159 
     - endDatetime
1160 
    """
1161 
    pass
5031 varun.gupt 1162 
 
5348 anupam.sin 1163 
  def updateCODAgent(self, agent, orderId):
1164 
    """
1165 
    Updates the agent who handled the COD verification call
1166 
 
1167 
    Parameters:
1168 
     - agent
1169 
     - orderId
1170 
    """
1171 
    pass
1172 
 
5099 varun.gupt 1173 
  def updateOrderAsPaidToVendor(self, orderId):
1174 
    """
1175 
    Parameters:
1176 
     - orderId
1177 
    """
1178 
    pass
5067 varun.gupt 1179 
 
5386 phani.kuma 1180 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1181 
    """
1182 
    Parameters:
1183 
     - orderId
1184 
    """
1185 
    pass
1186 
 
5208 varun.gupt 1187 
  def getRefundedOrdersMarkedPaid(self, ):
1188 
    pass
5099 varun.gupt 1189 
 
5447 anupam.sin 1190 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1191 
    """
1192 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1193 
 
5447 anupam.sin 1194 
 
1195 
    Parameters:
1196 
     - minOrderId
1197 
     - maxOrderId
1198 
    """
1199 
    pass
1200 
 
5527 anupam.sin 1201 
  def getAllAttributesForOrderId(self, orderId):
1202 
    """
1203 
    gets all attributes for a given orderId
5447 anupam.sin 1204 
 
5527 anupam.sin 1205 
    Parameters:
1206 
     - orderId
1207 
    """
1208 
    pass
1209 
 
5676 rajveer 1210 
  def setOrderAttributes(self, orderId, attributes):
1211 
    """
1212 
    sets attributes for an order
1213 
 
1214 
    Parameters:
1215 
     - orderId
1216 
     - attributes
1217 
    """
1218 
    pass
1219 
 
5527 anupam.sin 1220 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1221 
    """
1222 
    sets attributes for all orders in a transaction
1223 
 
1224 
    Parameters:
1225 
     - transactionId
1226 
     - attribute
1227 
    """
1228 
    pass
1229 
 
5553 rajveer 1230 
  def getReceivePendingOrders(self, storeId):
1231 
    """
1232 
    Parameters:
1233 
     - storeId
1234 
    """
1235 
    pass
5527 anupam.sin 1236 
 
5553 rajveer 1237 
  def getReceivedAtStoreOrders(self, storeId):
1238 
    """
1239 
    Parameters:
1240 
     - storeId
1241 
    """
1242 
    pass
1243 
 
5713 rajveer 1244 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1245 
    """
1246 
    Parameters:
1247 
     - storeId
1248 
     - fromDate
1249 
     - toDate
1250 
     - onlyCod
1251 
    """
1252 
    pass
1253 
 
5833 rajveer 1254 
  def getOrderAttributeValue(self, orderId, attributeName):
1255 
    """
1256 
    Parameters:
1257 
     - orderId
1258 
     - attributeName
1259 
    """
1260 
    pass
1261 
 
6019 rajveer 1262 
  def changeJacketNumber(self, orderId, jacketNumber):
1263 
    """
1264 
    Parameters:
1265 
     - orderId
1266 
     - jacketNumber
1267 
    """
1268 
    pass
1269 
 
1270 
  def markOrderAsRtoInTransit(self, orderId):
1271 
    """
1272 
    Parameters:
1273 
     - orderId
1274 
    """
1275 
    pass
1276 
 
5593 mandeep.dh 1277 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1278 
    """
1279 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1280 
    invoked while scanning IN of items.
5553 rajveer 1281 
 
5593 mandeep.dh 1282 
    Parameters:
1283 
     - itemId
1284 
     - quantity
1285 
     - fulfilmentWarehouseId
1286 
     - billingWarehouseId
1287 
    """
1288 
    pass
1289 
 
6000 mandeep.dh 1290 
  def createRechargeOrder(self, rechargeOrder):
1291 
    """
1292 
    Parameters:
1293 
     - rechargeOrder
1294 
    """
1295 
    pass
5593 mandeep.dh 1296 
 
6031 rajveer 1297 
  def getRechargeOrder(self, rechargeRrderId):
1298 
    """
1299 
    Parameters:
1300 
     - rechargeRrderId
1301 
    """
1302 
    pass
1303 
 
1304 
  def getRechargeOrders(self, userId):
1305 
    """
1306 
    Parameters:
1307 
     - userId
1308 
    """
1309 
    pass
1310 
 
6000 mandeep.dh 1311 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1312 
    """
1313 
    Parameters:
1314 
     - rechargeOrderId
1315 
     - rechargeOrderStatus
1316 
    """
1317 
    pass
1318 
 
6031 rajveer 1319 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1320 
    """
1321 
    Parameters:
6031 rajveer 1322 
     - rechargeOrderId
6000 mandeep.dh 1323 
    """
1324 
    pass
1325 
 
6031 rajveer 1326 
  def getUserWallet(self, userId):
6000 mandeep.dh 1327 
    """
1328 
    Parameters:
6031 rajveer 1329 
     - userId
6000 mandeep.dh 1330 
    """
1331 
    pass
1332 
 
6031 rajveer 1333 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1334 
    """
1335 
    Parameters:
6031 rajveer 1336 
     - userId
6000 mandeep.dh 1337 
    """
1338 
    pass
1339 
 
6048 rajveer 1340 
  def getServiceProviders(self, rechargeType):
1341 
    """
1342 
    Parameters:
1343 
     - rechargeType
1344 
    """
1345 
    pass
6000 mandeep.dh 1346 
 
6049 rajveer 1347 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1348 
    """
1349 
    Parameters:
6049 rajveer 1350 
     - rechargeType
6048 rajveer 1351 
     - deviceNumber
1352 
    """
1353 
    pass
1354 
 
1355 
 
3376 rajveer 1356 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1357 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1358 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1359 
 
1360 
  def createTransaction(self, transaction):
1361 
    """
1362 
    Parameters:
1363 
     - transaction
1364 
    """
1365 
    self.send_createTransaction(transaction)
132 ashish 1366 
    return self.recv_createTransaction()
94 ashish 1367 
 
1368 
  def send_createTransaction(self, transaction):
1369 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1370 
    args = createTransaction_args()
1371 
    args.transaction = transaction
1372 
    args.write(self._oprot)
1373 
    self._oprot.writeMessageEnd()
1374 
    self._oprot.trans.flush()
1375 
 
1376 
  def recv_createTransaction(self, ):
1377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1378 
    if mtype == TMessageType.EXCEPTION:
1379 
      x = TApplicationException()
1380 
      x.read(self._iprot)
1381 
      self._iprot.readMessageEnd()
1382 
      raise x
1383 
    result = createTransaction_result()
1384 
    result.read(self._iprot)
1385 
    self._iprot.readMessageEnd()
3431 rajveer 1386 
    if result.success is not None:
132 ashish 1387 
      return result.success
3431 rajveer 1388 
    if result.ex is not None:
94 ashish 1389 
      raise result.ex
132 ashish 1390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1391 
 
1392 
  def getTransaction(self, id):
1393 
    """
1394 
    Parameters:
1395 
     - id
1396 
    """
1397 
    self.send_getTransaction(id)
1398 
    return self.recv_getTransaction()
1399 
 
1400 
  def send_getTransaction(self, id):
1401 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1402 
    args = getTransaction_args()
1403 
    args.id = id
1404 
    args.write(self._oprot)
1405 
    self._oprot.writeMessageEnd()
1406 
    self._oprot.trans.flush()
1407 
 
1408 
  def recv_getTransaction(self, ):
1409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1410 
    if mtype == TMessageType.EXCEPTION:
1411 
      x = TApplicationException()
1412 
      x.read(self._iprot)
1413 
      self._iprot.readMessageEnd()
1414 
      raise x
1415 
    result = getTransaction_result()
1416 
    result.read(self._iprot)
1417 
    self._iprot.readMessageEnd()
3431 rajveer 1418 
    if result.success is not None:
94 ashish 1419 
      return result.success
3431 rajveer 1420 
    if result.ex is not None:
94 ashish 1421 
      raise result.ex
1422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1423 
 
1424 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1425 
    """
1426 
    Parameters:
1427 
     - customerId
1428 
     - from_date
1429 
     - to_date
1430 
     - status
1431 
    """
1432 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1433 
    return self.recv_getTransactionsForCustomer()
1434 
 
1435 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1436 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1437 
    args = getTransactionsForCustomer_args()
1438 
    args.customerId = customerId
1439 
    args.from_date = from_date
1440 
    args.to_date = to_date
1441 
    args.status = status
1442 
    args.write(self._oprot)
1443 
    self._oprot.writeMessageEnd()
1444 
    self._oprot.trans.flush()
1445 
 
1446 
  def recv_getTransactionsForCustomer(self, ):
1447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1448 
    if mtype == TMessageType.EXCEPTION:
1449 
      x = TApplicationException()
1450 
      x.read(self._iprot)
1451 
      self._iprot.readMessageEnd()
1452 
      raise x
1453 
    result = getTransactionsForCustomer_result()
1454 
    result.read(self._iprot)
1455 
    self._iprot.readMessageEnd()
3431 rajveer 1456 
    if result.success is not None:
94 ashish 1457 
      return result.success
3431 rajveer 1458 
    if result.ex is not None:
94 ashish 1459 
      raise result.ex
1460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1461 
 
132 ashish 1462 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1463 
    """
1464 
    Parameters:
1465 
     - shoppingCartId
1466 
    """
1467 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1468 
    return self.recv_getTransactionsForShoppingCartId()
1469 
 
1470 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1471 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1472 
    args = getTransactionsForShoppingCartId_args()
1473 
    args.shoppingCartId = shoppingCartId
1474 
    args.write(self._oprot)
1475 
    self._oprot.writeMessageEnd()
1476 
    self._oprot.trans.flush()
1477 
 
1478 
  def recv_getTransactionsForShoppingCartId(self, ):
1479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1480 
    if mtype == TMessageType.EXCEPTION:
1481 
      x = TApplicationException()
1482 
      x.read(self._iprot)
1483 
      self._iprot.readMessageEnd()
1484 
      raise x
1485 
    result = getTransactionsForShoppingCartId_result()
1486 
    result.read(self._iprot)
1487 
    self._iprot.readMessageEnd()
3431 rajveer 1488 
    if result.success is not None:
132 ashish 1489 
      return result.success
3431 rajveer 1490 
    if result.ex is not None:
132 ashish 1491 
      raise result.ex
1492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1493 
 
94 ashish 1494 
  def getTransactionStatus(self, transactionId):
1495 
    """
1496 
    Parameters:
1497 
     - transactionId
1498 
    """
1499 
    self.send_getTransactionStatus(transactionId)
1500 
    return self.recv_getTransactionStatus()
1501 
 
1502 
  def send_getTransactionStatus(self, transactionId):
1503 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1504 
    args = getTransactionStatus_args()
1505 
    args.transactionId = transactionId
1506 
    args.write(self._oprot)
1507 
    self._oprot.writeMessageEnd()
1508 
    self._oprot.trans.flush()
1509 
 
1510 
  def recv_getTransactionStatus(self, ):
1511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1512 
    if mtype == TMessageType.EXCEPTION:
1513 
      x = TApplicationException()
1514 
      x.read(self._iprot)
1515 
      self._iprot.readMessageEnd()
1516 
      raise x
1517 
    result = getTransactionStatus_result()
1518 
    result.read(self._iprot)
1519 
    self._iprot.readMessageEnd()
3431 rajveer 1520 
    if result.success is not None:
94 ashish 1521 
      return result.success
3431 rajveer 1522 
    if result.ex is not None:
94 ashish 1523 
      raise result.ex
1524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1525 
 
5527 anupam.sin 1526 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1527 
    """
1528 
    Parameters:
1529 
     - transactionId
1530 
     - status
1531 
     - description
5527 anupam.sin 1532 
     - pickUp
1533 
     - orderType
94 ashish 1534 
    """
5527 anupam.sin 1535 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1536 
    return self.recv_changeTransactionStatus()
1537 
 
5527 anupam.sin 1538 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1539 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1540 
    args = changeTransactionStatus_args()
1541 
    args.transactionId = transactionId
1542 
    args.status = status
1543 
    args.description = description
5527 anupam.sin 1544 
    args.pickUp = pickUp
1545 
    args.orderType = orderType
94 ashish 1546 
    args.write(self._oprot)
1547 
    self._oprot.writeMessageEnd()
1548 
    self._oprot.trans.flush()
1549 
 
1550 
  def recv_changeTransactionStatus(self, ):
1551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1552 
    if mtype == TMessageType.EXCEPTION:
1553 
      x = TApplicationException()
1554 
      x.read(self._iprot)
1555 
      self._iprot.readMessageEnd()
1556 
      raise x
1557 
    result = changeTransactionStatus_result()
1558 
    result.read(self._iprot)
1559 
    self._iprot.readMessageEnd()
3431 rajveer 1560 
    if result.success is not None:
94 ashish 1561 
      return result.success
3431 rajveer 1562 
    if result.ex is not None:
94 ashish 1563 
      raise result.ex
1564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1565 
 
1398 varun.gupt 1566 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1567 
    """
1568 
    Parameters:
1569 
     - transactionId
1570 
    """
1398 varun.gupt 1571 
    self.send_enqueueTransactionInfoEmail(transactionId)
1572 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1573 
 
1398 varun.gupt 1574 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1575 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1576 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1577 
    args.transactionId = transactionId
1578 
    args.write(self._oprot)
1579 
    self._oprot.writeMessageEnd()
1580 
    self._oprot.trans.flush()
1581 
 
1398 varun.gupt 1582 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1584 
    if mtype == TMessageType.EXCEPTION:
1585 
      x = TApplicationException()
1586 
      x.read(self._iprot)
1587 
      self._iprot.readMessageEnd()
1588 
      raise x
1398 varun.gupt 1589 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1590 
    result.read(self._iprot)
1591 
    self._iprot.readMessageEnd()
3431 rajveer 1592 
    if result.success is not None:
1382 varun.gupt 1593 
      return result.success
3431 rajveer 1594 
    if result.ex is not None:
1382 varun.gupt 1595 
      raise result.ex
1398 varun.gupt 1596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1597 
 
4801 anupam.sin 1598 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1599 
    """
1600 
    Parameters:
4801 anupam.sin 1601 
     - statuses
483 rajveer 1602 
     - from_date
1603 
     - to_date
1604 
     - warehouse_id
94 ashish 1605 
    """
4801 anupam.sin 1606 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1607 
    return self.recv_getAllOrders()
94 ashish 1608 
 
4801 anupam.sin 1609 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1610 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1611 
    args = getAllOrders_args()
4801 anupam.sin 1612 
    args.statuses = statuses
483 rajveer 1613 
    args.from_date = from_date
1614 
    args.to_date = to_date
1615 
    args.warehouse_id = warehouse_id
94 ashish 1616 
    args.write(self._oprot)
1617 
    self._oprot.writeMessageEnd()
1618 
    self._oprot.trans.flush()
1619 
 
483 rajveer 1620 
  def recv_getAllOrders(self, ):
94 ashish 1621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1622 
    if mtype == TMessageType.EXCEPTION:
1623 
      x = TApplicationException()
1624 
      x.read(self._iprot)
1625 
      self._iprot.readMessageEnd()
1626 
      raise x
483 rajveer 1627 
    result = getAllOrders_result()
94 ashish 1628 
    result.read(self._iprot)
1629 
    self._iprot.readMessageEnd()
3431 rajveer 1630 
    if result.success is not None:
94 ashish 1631 
      return result.success
3431 rajveer 1632 
    if result.ex is not None:
94 ashish 1633 
      raise result.ex
483 rajveer 1634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1635 
 
4133 chandransh 1636 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1637 
    """
1638 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1639 
    Pass the status as null and the limit as 0 to ignore them.
1640 
 
1641 
    Parameters:
1642 
     - statuses
1643 
     - offset
1644 
     - limit
1645 
     - warehouse_id
1646 
    """
1647 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1648 
    return self.recv_getOrdersInBatch()
1649 
 
1650 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1651 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1652 
    args = getOrdersInBatch_args()
1653 
    args.statuses = statuses
1654 
    args.offset = offset
1655 
    args.limit = limit
1656 
    args.warehouse_id = warehouse_id
1657 
    args.write(self._oprot)
1658 
    self._oprot.writeMessageEnd()
1659 
    self._oprot.trans.flush()
1660 
 
1661 
  def recv_getOrdersInBatch(self, ):
1662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1663 
    if mtype == TMessageType.EXCEPTION:
1664 
      x = TApplicationException()
1665 
      x.read(self._iprot)
1666 
      self._iprot.readMessageEnd()
1667 
      raise x
1668 
    result = getOrdersInBatch_result()
1669 
    result.read(self._iprot)
1670 
    self._iprot.readMessageEnd()
1671 
    if result.success is not None:
1672 
      return result.success
1673 
    if result.ex is not None:
1674 
      raise result.ex
1675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1676 
 
1677 
  def getOrderCount(self, statuses, warehouseId):
1678 
    """
1679 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1680 
 
1681 
    Parameters:
1682 
     - statuses
1683 
     - warehouseId
1684 
    """
1685 
    self.send_getOrderCount(statuses, warehouseId)
1686 
    return self.recv_getOrderCount()
1687 
 
1688 
  def send_getOrderCount(self, statuses, warehouseId):
1689 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1690 
    args = getOrderCount_args()
1691 
    args.statuses = statuses
1692 
    args.warehouseId = warehouseId
1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
1697 
  def recv_getOrderCount(self, ):
1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
1704 
    result = getOrderCount_result()
1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
1707 
    if result.success is not None:
1708 
      return result.success
1709 
    if result.ex is not None:
1710 
      raise result.ex
1711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1712 
 
999 varun.gupt 1713 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1714 
    """
1132 chandransh 1715 
    Returns orders within a range of their billing dates
3431 rajveer 1716 
 
999 varun.gupt 1717 
    Parameters:
1718 
     - status
1719 
     - start_billing_date
1720 
     - end_billing_date
1721 
     - warehouse_id
1722 
    """
1723 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1724 
    return self.recv_getOrdersByBillingDate()
1725 
 
1726 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1727 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1728 
    args = getOrdersByBillingDate_args()
1729 
    args.status = status
1730 
    args.start_billing_date = start_billing_date
1731 
    args.end_billing_date = end_billing_date
1732 
    args.warehouse_id = warehouse_id
1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_getOrdersByBillingDate(self, ):
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
1744 
    result = getOrdersByBillingDate_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
3431 rajveer 1747 
    if result.success is not None:
999 varun.gupt 1748 
      return result.success
3431 rajveer 1749 
    if result.ex is not None:
999 varun.gupt 1750 
      raise result.ex
1751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1752 
 
3451 chandransh 1753 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1754 
    """
1755 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1756 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1757 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1758 
 
3427 chandransh 1759 
    Parameters:
1760 
     - fromShippingDate
1761 
     - toShippingDate
1762 
     - providerId
1763 
     - warehouseId
3451 chandransh 1764 
     - cod
3427 chandransh 1765 
    """
3451 chandransh 1766 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1767 
    return self.recv_getOrdersByShippingDate()
1768 
 
3451 chandransh 1769 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1770 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1771 
    args = getOrdersByShippingDate_args()
1772 
    args.fromShippingDate = fromShippingDate
1773 
    args.toShippingDate = toShippingDate
1774 
    args.providerId = providerId
1775 
    args.warehouseId = warehouseId
3451 chandransh 1776 
    args.cod = cod
3427 chandransh 1777 
    args.write(self._oprot)
1778 
    self._oprot.writeMessageEnd()
1779 
    self._oprot.trans.flush()
1780 
 
1781 
  def recv_getOrdersByShippingDate(self, ):
1782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1783 
    if mtype == TMessageType.EXCEPTION:
1784 
      x = TApplicationException()
1785 
      x.read(self._iprot)
1786 
      self._iprot.readMessageEnd()
1787 
      raise x
1788 
    result = getOrdersByShippingDate_result()
1789 
    result.read(self._iprot)
1790 
    self._iprot.readMessageEnd()
3431 rajveer 1791 
    if result.success is not None:
3427 chandransh 1792 
      return result.success
3431 rajveer 1793 
    if result.ex is not None:
3427 chandransh 1794 
      raise result.ex
1795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1796 
 
1382 varun.gupt 1797 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1798 
    """
1799 
    Returns order ids for orders which can be returned
3431 rajveer 1800 
 
1382 varun.gupt 1801 
    Parameters:
1802 
     - customer_id
1803 
     - limit
1804 
    """
1805 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1806 
    return self.recv_getReturnableOrdersForCustomer()
1807 
 
1808 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1809 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1810 
    args = getReturnableOrdersForCustomer_args()
1811 
    args.customer_id = customer_id
1812 
    args.limit = limit
1813 
    args.write(self._oprot)
1814 
    self._oprot.writeMessageEnd()
1815 
    self._oprot.trans.flush()
1816 
 
1817 
  def recv_getReturnableOrdersForCustomer(self, ):
1818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1819 
    if mtype == TMessageType.EXCEPTION:
1820 
      x = TApplicationException()
1821 
      x.read(self._iprot)
1822 
      self._iprot.readMessageEnd()
1823 
      raise x
1824 
    result = getReturnableOrdersForCustomer_result()
1825 
    result.read(self._iprot)
1826 
    self._iprot.readMessageEnd()
3431 rajveer 1827 
    if result.success is not None:
1382 varun.gupt 1828 
      return result.success
3431 rajveer 1829 
    if result.ex is not None:
1382 varun.gupt 1830 
      raise result.ex
1831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1832 
 
1833 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1834 
    """
1835 
    Returns order ids for orders which can be cancelled
3431 rajveer 1836 
 
1382 varun.gupt 1837 
    Parameters:
1838 
     - customer_id
1839 
     - limit
1840 
    """
1841 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1842 
    return self.recv_getCancellableOrdersForCustomer()
1843 
 
1844 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1845 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1846 
    args = getCancellableOrdersForCustomer_args()
1847 
    args.customer_id = customer_id
1848 
    args.limit = limit
1849 
    args.write(self._oprot)
1850 
    self._oprot.writeMessageEnd()
1851 
    self._oprot.trans.flush()
1852 
 
1853 
  def recv_getCancellableOrdersForCustomer(self, ):
1854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1855 
    if mtype == TMessageType.EXCEPTION:
1856 
      x = TApplicationException()
1857 
      x.read(self._iprot)
1858 
      self._iprot.readMessageEnd()
1859 
      raise x
1860 
    result = getCancellableOrdersForCustomer_result()
1861 
    result.read(self._iprot)
1862 
    self._iprot.readMessageEnd()
3431 rajveer 1863 
    if result.success is not None:
1382 varun.gupt 1864 
      return result.success
3431 rajveer 1865 
    if result.ex is not None:
1382 varun.gupt 1866 
      raise result.ex
1867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1868 
 
483 rajveer 1869 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1870 
    """
1871 
    Parameters:
483 rajveer 1872 
     - orderId
1873 
     - status
1874 
     - description
94 ashish 1875 
    """
483 rajveer 1876 
    self.send_changeOrderStatus(orderId, status, description)
1877 
    return self.recv_changeOrderStatus()
94 ashish 1878 
 
483 rajveer 1879 
  def send_changeOrderStatus(self, orderId, status, description):
1880 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1881 
    args = changeOrderStatus_args()
1882 
    args.orderId = orderId
1883 
    args.status = status
1884 
    args.description = description
94 ashish 1885 
    args.write(self._oprot)
1886 
    self._oprot.writeMessageEnd()
1887 
    self._oprot.trans.flush()
1888 
 
483 rajveer 1889 
  def recv_changeOrderStatus(self, ):
94 ashish 1890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1891 
    if mtype == TMessageType.EXCEPTION:
1892 
      x = TApplicationException()
1893 
      x.read(self._iprot)
1894 
      self._iprot.readMessageEnd()
1895 
      raise x
483 rajveer 1896 
    result = changeOrderStatus_result()
94 ashish 1897 
    result.read(self._iprot)
1898 
    self._iprot.readMessageEnd()
3431 rajveer 1899 
    if result.success is not None:
94 ashish 1900 
      return result.success
3431 rajveer 1901 
    if result.ex is not None:
94 ashish 1902 
      raise result.ex
483 rajveer 1903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1904 
 
1528 ankur.sing 1905 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1906 
    """
1528 ankur.sing 1907 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1908 
    only user who owns the transaction can view its order details.
3431 rajveer 1909 
 
94 ashish 1910 
    Parameters:
1911 
     - transactionId
1528 ankur.sing 1912 
     - customerId
94 ashish 1913 
    """
1528 ankur.sing 1914 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1915 
    return self.recv_getOrdersForTransaction()
94 ashish 1916 
 
1528 ankur.sing 1917 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1918 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1919 
    args = getOrdersForTransaction_args()
94 ashish 1920 
    args.transactionId = transactionId
1528 ankur.sing 1921 
    args.customerId = customerId
94 ashish 1922 
    args.write(self._oprot)
1923 
    self._oprot.writeMessageEnd()
1924 
    self._oprot.trans.flush()
1925 
 
483 rajveer 1926 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1928 
    if mtype == TMessageType.EXCEPTION:
1929 
      x = TApplicationException()
1930 
      x.read(self._iprot)
1931 
      self._iprot.readMessageEnd()
1932 
      raise x
483 rajveer 1933 
    result = getOrdersForTransaction_result()
94 ashish 1934 
    result.read(self._iprot)
1935 
    self._iprot.readMessageEnd()
3431 rajveer 1936 
    if result.success is not None:
94 ashish 1937 
      return result.success
3431 rajveer 1938 
    if result.ex is not None:
94 ashish 1939 
      raise result.ex
483 rajveer 1940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1941 
 
3014 chandransh 1942 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1943 
    """
3014 chandransh 1944 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1945 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1946 
 
94 ashish 1947 
    Parameters:
483 rajveer 1948 
     - customerId
1949 
     - from_date
1950 
     - to_date
3014 chandransh 1951 
     - statuses
94 ashish 1952 
    """
3014 chandransh 1953 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1954 
    return self.recv_getOrdersForCustomer()
94 ashish 1955 
 
3014 chandransh 1956 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1957 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1958 
    args = getOrdersForCustomer_args()
1959 
    args.customerId = customerId
1960 
    args.from_date = from_date
1961 
    args.to_date = to_date
3014 chandransh 1962 
    args.statuses = statuses
94 ashish 1963 
    args.write(self._oprot)
1964 
    self._oprot.writeMessageEnd()
1965 
    self._oprot.trans.flush()
1966 
 
483 rajveer 1967 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1969 
    if mtype == TMessageType.EXCEPTION:
1970 
      x = TApplicationException()
1971 
      x.read(self._iprot)
1972 
      self._iprot.readMessageEnd()
1973 
      raise x
483 rajveer 1974 
    result = getOrdersForCustomer_result()
94 ashish 1975 
    result.read(self._iprot)
1976 
    self._iprot.readMessageEnd()
3431 rajveer 1977 
    if result.success is not None:
94 ashish 1978 
      return result.success
3431 rajveer 1979 
    if result.ex is not None:
94 ashish 1980 
      raise result.ex
483 rajveer 1981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1982 
 
483 rajveer 1983 
  def createOrder(self, order):
94 ashish 1984 
    """
1985 
    Parameters:
483 rajveer 1986 
     - order
94 ashish 1987 
    """
483 rajveer 1988 
    self.send_createOrder(order)
1989 
    return self.recv_createOrder()
94 ashish 1990 
 
483 rajveer 1991 
  def send_createOrder(self, order):
1992 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1993 
    args = createOrder_args()
1994 
    args.order = order
94 ashish 1995 
    args.write(self._oprot)
1996 
    self._oprot.writeMessageEnd()
1997 
    self._oprot.trans.flush()
1998 
 
483 rajveer 1999 
  def recv_createOrder(self, ):
94 ashish 2000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2001 
    if mtype == TMessageType.EXCEPTION:
2002 
      x = TApplicationException()
2003 
      x.read(self._iprot)
2004 
      self._iprot.readMessageEnd()
2005 
      raise x
483 rajveer 2006 
    result = createOrder_result()
94 ashish 2007 
    result.read(self._iprot)
2008 
    self._iprot.readMessageEnd()
3431 rajveer 2009 
    if result.success is not None:
94 ashish 2010 
      return result.success
3431 rajveer 2011 
    if result.ex is not None:
94 ashish 2012 
      raise result.ex
483 rajveer 2013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2014 
 
483 rajveer 2015 
  def getOrder(self, id):
94 ashish 2016 
    """
2017 
    Parameters:
483 rajveer 2018 
     - id
94 ashish 2019 
    """
483 rajveer 2020 
    self.send_getOrder(id)
2021 
    return self.recv_getOrder()
94 ashish 2022 
 
483 rajveer 2023 
  def send_getOrder(self, id):
2024 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2025 
    args = getOrder_args()
2026 
    args.id = id
94 ashish 2027 
    args.write(self._oprot)
2028 
    self._oprot.writeMessageEnd()
2029 
    self._oprot.trans.flush()
2030 
 
483 rajveer 2031 
  def recv_getOrder(self, ):
94 ashish 2032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2033 
    if mtype == TMessageType.EXCEPTION:
2034 
      x = TApplicationException()
2035 
      x.read(self._iprot)
2036 
      self._iprot.readMessageEnd()
2037 
      raise x
483 rajveer 2038 
    result = getOrder_result()
94 ashish 2039 
    result.read(self._iprot)
2040 
    self._iprot.readMessageEnd()
3431 rajveer 2041 
    if result.success is not None:
94 ashish 2042 
      return result.success
3431 rajveer 2043 
    if result.ex is not None:
94 ashish 2044 
      raise result.ex
483 rajveer 2045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2046 
 
483 rajveer 2047 
  def getLineItemsForOrder(self, orderId):
94 ashish 2048 
    """
2049 
    Parameters:
483 rajveer 2050 
     - orderId
94 ashish 2051 
    """
483 rajveer 2052 
    self.send_getLineItemsForOrder(orderId)
2053 
    return self.recv_getLineItemsForOrder()
94 ashish 2054 
 
483 rajveer 2055 
  def send_getLineItemsForOrder(self, orderId):
2056 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2057 
    args = getLineItemsForOrder_args()
2058 
    args.orderId = orderId
94 ashish 2059 
    args.write(self._oprot)
2060 
    self._oprot.writeMessageEnd()
2061 
    self._oprot.trans.flush()
2062 
 
483 rajveer 2063 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2065 
    if mtype == TMessageType.EXCEPTION:
2066 
      x = TApplicationException()
2067 
      x.read(self._iprot)
2068 
      self._iprot.readMessageEnd()
2069 
      raise x
483 rajveer 2070 
    result = getLineItemsForOrder_result()
94 ashish 2071 
    result.read(self._iprot)
2072 
    self._iprot.readMessageEnd()
3431 rajveer 2073 
    if result.success is not None:
94 ashish 2074 
      return result.success
3431 rajveer 2075 
    if result.ex is not None:
94 ashish 2076 
      raise result.ex
483 rajveer 2077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2078 
 
4999 phani.kuma 2079 
  def getOrderList(self, order_ids):
2080 
    """
2081 
    Parameters:
2082 
     - order_ids
2083 
    """
2084 
    self.send_getOrderList(order_ids)
2085 
    return self.recv_getOrderList()
2086 
 
2087 
  def send_getOrderList(self, order_ids):
2088 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2089 
    args = getOrderList_args()
2090 
    args.order_ids = order_ids
2091 
    args.write(self._oprot)
2092 
    self._oprot.writeMessageEnd()
2093 
    self._oprot.trans.flush()
2094 
 
2095 
  def recv_getOrderList(self, ):
2096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2097 
    if mtype == TMessageType.EXCEPTION:
2098 
      x = TApplicationException()
2099 
      x.read(self._iprot)
2100 
      self._iprot.readMessageEnd()
2101 
      raise x
2102 
    result = getOrderList_result()
2103 
    result.read(self._iprot)
2104 
    self._iprot.readMessageEnd()
2105 
    if result.success is not None:
2106 
      return result.success
2107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2108 
 
5386 phani.kuma 2109 
  def getOrderListForVendor(self, order_ids, vendorId):
2110 
    """
2111 
    Parameters:
2112 
     - order_ids
2113 
     - vendorId
2114 
    """
2115 
    self.send_getOrderListForVendor(order_ids, vendorId)
2116 
    return self.recv_getOrderListForVendor()
2117 
 
2118 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2119 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2120 
    args = getOrderListForVendor_args()
2121 
    args.order_ids = order_ids
2122 
    args.vendorId = vendorId
2123 
    args.write(self._oprot)
2124 
    self._oprot.writeMessageEnd()
2125 
    self._oprot.trans.flush()
2126 
 
2127 
  def recv_getOrderListForVendor(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 = getOrderListForVendor_result()
2135 
    result.read(self._iprot)
2136 
    self._iprot.readMessageEnd()
2137 
    if result.success is not None:
2138 
      return result.success
2139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2140 
 
1528 ankur.sing 2141 
  def getOrderForCustomer(self, orderId, customerId):
2142 
    """
2143 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2144 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2145 
 
1528 ankur.sing 2146 
    Parameters:
2147 
     - orderId
2148 
     - customerId
2149 
    """
2150 
    self.send_getOrderForCustomer(orderId, customerId)
2151 
    return self.recv_getOrderForCustomer()
2152 
 
2153 
  def send_getOrderForCustomer(self, orderId, customerId):
2154 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2155 
    args = getOrderForCustomer_args()
2156 
    args.orderId = orderId
2157 
    args.customerId = customerId
2158 
    args.write(self._oprot)
2159 
    self._oprot.writeMessageEnd()
2160 
    self._oprot.trans.flush()
2161 
 
2162 
  def recv_getOrderForCustomer(self, ):
2163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2164 
    if mtype == TMessageType.EXCEPTION:
2165 
      x = TApplicationException()
2166 
      x.read(self._iprot)
2167 
      self._iprot.readMessageEnd()
2168 
      raise x
2169 
    result = getOrderForCustomer_result()
2170 
    result.read(self._iprot)
2171 
    self._iprot.readMessageEnd()
3431 rajveer 2172 
    if result.success is not None:
1528 ankur.sing 2173 
      return result.success
3431 rajveer 2174 
    if result.ex is not None:
1528 ankur.sing 2175 
      raise result.ex
2176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2177 
 
4444 rajveer 2178 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2179 
    """
2180 
    Parameters:
4394 rajveer 2181 
     - type
4444 rajveer 2182 
     - warehouseId
4394 rajveer 2183 
     - status
2184 
     - timestamp
3064 chandransh 2185 
    """
4444 rajveer 2186 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2187 
    return self.recv_getAlerts()
2188 
 
4444 rajveer 2189 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2190 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2191 
    args = getAlerts_args()
4394 rajveer 2192 
    args.type = type
4444 rajveer 2193 
    args.warehouseId = warehouseId
4394 rajveer 2194 
    args.status = status
2195 
    args.timestamp = timestamp
3064 chandransh 2196 
    args.write(self._oprot)
2197 
    self._oprot.writeMessageEnd()
2198 
    self._oprot.trans.flush()
2199 
 
2200 
  def recv_getAlerts(self, ):
2201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2202 
    if mtype == TMessageType.EXCEPTION:
2203 
      x = TApplicationException()
2204 
      x.read(self._iprot)
2205 
      self._iprot.readMessageEnd()
2206 
      raise x
2207 
    result = getAlerts_result()
2208 
    result.read(self._iprot)
2209 
    self._iprot.readMessageEnd()
3431 rajveer 2210 
    if result.success is not None:
3064 chandransh 2211 
      return result.success
2212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2213 
 
4444 rajveer 2214 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2215 
    """
2216 
    Parameters:
2217 
     - type
4444 rajveer 2218 
     - warehouseId
4394 rajveer 2219 
     - description
3064 chandransh 2220 
    """
4444 rajveer 2221 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2222 
    self.recv_addAlert()
3064 chandransh 2223 
 
4444 rajveer 2224 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2225 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2226 
    args = addAlert_args()
3064 chandransh 2227 
    args.type = type
4444 rajveer 2228 
    args.warehouseId = warehouseId
4394 rajveer 2229 
    args.description = description
3064 chandransh 2230 
    args.write(self._oprot)
2231 
    self._oprot.writeMessageEnd()
2232 
    self._oprot.trans.flush()
2233 
 
4394 rajveer 2234 
  def recv_addAlert(self, ):
3064 chandransh 2235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2236 
    if mtype == TMessageType.EXCEPTION:
2237 
      x = TApplicationException()
2238 
      x.read(self._iprot)
2239 
      self._iprot.readMessageEnd()
2240 
      raise x
4394 rajveer 2241 
    result = addAlert_result()
3064 chandransh 2242 
    result.read(self._iprot)
2243 
    self._iprot.readMessageEnd()
2244 
    return
2245 
 
4444 rajveer 2246 
  def markAlertsAsSeen(self, warehouseId):
2247 
    """
2248 
    Parameters:
2249 
     - warehouseId
2250 
    """
2251 
    self.send_markAlertsAsSeen(warehouseId)
2252 
    self.recv_markAlertsAsSeen()
2253 
 
2254 
  def send_markAlertsAsSeen(self, warehouseId):
2255 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2256 
    args = markAlertsAsSeen_args()
2257 
    args.warehouseId = warehouseId
2258 
    args.write(self._oprot)
2259 
    self._oprot.writeMessageEnd()
2260 
    self._oprot.trans.flush()
2261 
 
2262 
  def recv_markAlertsAsSeen(self, ):
2263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2264 
    if mtype == TMessageType.EXCEPTION:
2265 
      x = TApplicationException()
2266 
      x.read(self._iprot)
2267 
      self._iprot.readMessageEnd()
2268 
      raise x
2269 
    result = markAlertsAsSeen_result()
2270 
    result.read(self._iprot)
2271 
    self._iprot.readMessageEnd()
2272 
    return
2273 
 
3064 chandransh 2274 
  def getValidOrderCount(self, ):
2275 
    """
2276 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2277 
    """
2278 
    self.send_getValidOrderCount()
2279 
    return self.recv_getValidOrderCount()
2280 
 
2281 
  def send_getValidOrderCount(self, ):
2282 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2283 
    args = getValidOrderCount_args()
2284 
    args.write(self._oprot)
2285 
    self._oprot.writeMessageEnd()
2286 
    self._oprot.trans.flush()
2287 
 
2288 
  def recv_getValidOrderCount(self, ):
2289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2290 
    if mtype == TMessageType.EXCEPTION:
2291 
      x = TApplicationException()
2292 
      x.read(self._iprot)
2293 
      self._iprot.readMessageEnd()
2294 
      raise x
2295 
    result = getValidOrderCount_result()
2296 
    result.read(self._iprot)
2297 
    self._iprot.readMessageEnd()
3431 rajveer 2298 
    if result.success is not None:
3064 chandransh 2299 
      return result.success
2300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2301 
 
2302 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2303 
    """
2304 
    Returns the number of distinct customers who have done successful transactions
2305 
    """
2306 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2307 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2308 
 
2309 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2310 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2311 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2312 
    args.write(self._oprot)
2313 
    self._oprot.writeMessageEnd()
2314 
    self._oprot.trans.flush()
2315 
 
2316 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2318 
    if mtype == TMessageType.EXCEPTION:
2319 
      x = TApplicationException()
2320 
      x.read(self._iprot)
2321 
      self._iprot.readMessageEnd()
2322 
      raise x
2323 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2324 
    result.read(self._iprot)
2325 
    self._iprot.readMessageEnd()
3431 rajveer 2326 
    if result.success is not None:
3064 chandransh 2327 
      return result.success
2328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2329 
 
2330 
  def getValidOrdersAmountRange(self, ):
2331 
    """
2332 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2333 
    List contains two values, first minimum amount and second maximum amount.
2334 
    """
2335 
    self.send_getValidOrdersAmountRange()
2336 
    return self.recv_getValidOrdersAmountRange()
2337 
 
2338 
  def send_getValidOrdersAmountRange(self, ):
2339 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2340 
    args = getValidOrdersAmountRange_args()
2341 
    args.write(self._oprot)
2342 
    self._oprot.writeMessageEnd()
2343 
    self._oprot.trans.flush()
2344 
 
2345 
  def recv_getValidOrdersAmountRange(self, ):
2346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2347 
    if mtype == TMessageType.EXCEPTION:
2348 
      x = TApplicationException()
2349 
      x.read(self._iprot)
2350 
      self._iprot.readMessageEnd()
2351 
      raise x
2352 
    result = getValidOrdersAmountRange_result()
2353 
    result.read(self._iprot)
2354 
    self._iprot.readMessageEnd()
3431 rajveer 2355 
    if result.success is not None:
3064 chandransh 2356 
      return result.success
2357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2358 
 
5874 rajveer 2359 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2360 
    """
2361 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2362 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2363 
 
3064 chandransh 2364 
    Parameters:
2365 
     - limit
5874 rajveer 2366 
     - onlyStore
3064 chandransh 2367 
    """
5874 rajveer 2368 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2369 
    return self.recv_getValidOrders()
2370 
 
5874 rajveer 2371 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2372 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2373 
    args = getValidOrders_args()
2374 
    args.limit = limit
5874 rajveer 2375 
    args.onlyStore = onlyStore
3064 chandransh 2376 
    args.write(self._oprot)
2377 
    self._oprot.writeMessageEnd()
2378 
    self._oprot.trans.flush()
2379 
 
2380 
  def recv_getValidOrders(self, ):
2381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2382 
    if mtype == TMessageType.EXCEPTION:
2383 
      x = TApplicationException()
2384 
      x.read(self._iprot)
2385 
      self._iprot.readMessageEnd()
2386 
      raise x
2387 
    result = getValidOrders_result()
2388 
    result.read(self._iprot)
2389 
    self._iprot.readMessageEnd()
3431 rajveer 2390 
    if result.success is not None:
3064 chandransh 2391 
      return result.success
2392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2393 
 
1220 chandransh 2394 
  def batchOrders(self, warehouseId):
2395 
    """
2396 
    Create a batch of all the pending orders for the given warehouse.
2397 
    The returned list is orderd by created_timestamp.
2398 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2399 
 
1220 chandransh 2400 
    Parameters:
2401 
     - warehouseId
2402 
    """
2403 
    self.send_batchOrders(warehouseId)
2404 
    return self.recv_batchOrders()
2405 
 
2406 
  def send_batchOrders(self, warehouseId):
2407 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2408 
    args = batchOrders_args()
2409 
    args.warehouseId = warehouseId
2410 
    args.write(self._oprot)
2411 
    self._oprot.writeMessageEnd()
2412 
    self._oprot.trans.flush()
2413 
 
2414 
  def recv_batchOrders(self, ):
2415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2416 
    if mtype == TMessageType.EXCEPTION:
2417 
      x = TApplicationException()
2418 
      x.read(self._iprot)
2419 
      self._iprot.readMessageEnd()
2420 
      raise x
2421 
    result = batchOrders_result()
2422 
    result.read(self._iprot)
2423 
    self._iprot.readMessageEnd()
3431 rajveer 2424 
    if result.success is not None:
1220 chandransh 2425 
      return result.success
3431 rajveer 2426 
    if result.ex is not None:
1220 chandransh 2427 
      raise result.ex
2428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2429 
 
1208 chandransh 2430 
  def markOrderAsOutOfStock(self, orderId):
2431 
    """
2432 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2433 
 
1208 chandransh 2434 
    Parameters:
2435 
     - orderId
2436 
    """
2437 
    self.send_markOrderAsOutOfStock(orderId)
2438 
    return self.recv_markOrderAsOutOfStock()
2439 
 
2440 
  def send_markOrderAsOutOfStock(self, orderId):
2441 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2442 
    args = markOrderAsOutOfStock_args()
2443 
    args.orderId = orderId
2444 
    args.write(self._oprot)
2445 
    self._oprot.writeMessageEnd()
2446 
    self._oprot.trans.flush()
2447 
 
2448 
  def recv_markOrderAsOutOfStock(self, ):
2449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2450 
    if mtype == TMessageType.EXCEPTION:
2451 
      x = TApplicationException()
2452 
      x.read(self._iprot)
2453 
      self._iprot.readMessageEnd()
2454 
      raise x
2455 
    result = markOrderAsOutOfStock_result()
2456 
    result.read(self._iprot)
2457 
    self._iprot.readMessageEnd()
3431 rajveer 2458 
    if result.success is not None:
1208 chandransh 2459 
      return result.success
3431 rajveer 2460 
    if result.ex is not None:
1208 chandransh 2461 
      raise result.ex
2462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2463 
 
3064 chandransh 2464 
  def verifyOrder(self, orderId):
759 chandransh 2465 
    """
3064 chandransh 2466 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2467 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2468 
    used for all other orders as well.
2469 
    Throws an exception if no such order exists.
3431 rajveer 2470 
 
759 chandransh 2471 
    Parameters:
3064 chandransh 2472 
     - orderId
759 chandransh 2473 
    """
3064 chandransh 2474 
    self.send_verifyOrder(orderId)
2475 
    return self.recv_verifyOrder()
759 chandransh 2476 
 
3064 chandransh 2477 
  def send_verifyOrder(self, orderId):
2478 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2479 
    args = verifyOrder_args()
2480 
    args.orderId = orderId
759 chandransh 2481 
    args.write(self._oprot)
2482 
    self._oprot.writeMessageEnd()
2483 
    self._oprot.trans.flush()
2484 
 
3064 chandransh 2485 
  def recv_verifyOrder(self, ):
759 chandransh 2486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2487 
    if mtype == TMessageType.EXCEPTION:
2488 
      x = TApplicationException()
2489 
      x.read(self._iprot)
2490 
      self._iprot.readMessageEnd()
2491 
      raise x
3064 chandransh 2492 
    result = verifyOrder_result()
759 chandransh 2493 
    result.read(self._iprot)
2494 
    self._iprot.readMessageEnd()
3431 rajveer 2495 
    if result.success is not None:
759 chandransh 2496 
      return result.success
3431 rajveer 2497 
    if result.ex is not None:
759 chandransh 2498 
      raise result.ex
3064 chandransh 2499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2500 
 
3064 chandransh 2501 
  def acceptOrder(self, orderId):
1113 chandransh 2502 
    """
3064 chandransh 2503 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2504 
    given order is not a COD order, it also captures the payment if the same has
2505 
    not been captured.
2506 
    Throws an exception if no such order exists.
3431 rajveer 2507 
 
1113 chandransh 2508 
    Parameters:
3064 chandransh 2509 
     - orderId
1113 chandransh 2510 
    """
3064 chandransh 2511 
    self.send_acceptOrder(orderId)
2512 
    return self.recv_acceptOrder()
1113 chandransh 2513 
 
3064 chandransh 2514 
  def send_acceptOrder(self, orderId):
2515 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2516 
    args = acceptOrder_args()
2517 
    args.orderId = orderId
1113 chandransh 2518 
    args.write(self._oprot)
2519 
    self._oprot.writeMessageEnd()
2520 
    self._oprot.trans.flush()
2521 
 
3064 chandransh 2522 
  def recv_acceptOrder(self, ):
1113 chandransh 2523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2524 
    if mtype == TMessageType.EXCEPTION:
2525 
      x = TApplicationException()
2526 
      x.read(self._iprot)
2527 
      self._iprot.readMessageEnd()
2528 
      raise x
3064 chandransh 2529 
    result = acceptOrder_result()
1113 chandransh 2530 
    result.read(self._iprot)
2531 
    self._iprot.readMessageEnd()
3431 rajveer 2532 
    if result.success is not None:
1113 chandransh 2533 
      return result.success
3431 rajveer 2534 
    if result.ex is not None:
1113 chandransh 2535 
      raise result.ex
3064 chandransh 2536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2537 
 
5110 mandeep.dh 2538 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2539 
    """
3064 chandransh 2540 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2541 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2542 
    the IMEI no. if a -1 is supplied.
2543 
    Also, it generates an invoice number for the order, marks the order as
2544 
    BILLED and sets the billing timestamp.
2545 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2546 
 
1135 chandransh 2547 
    Parameters:
3064 chandransh 2548 
     - orderId
2549 
     - invoice_number
4658 mandeep.dh 2550 
     - serialNumber
4283 anupam.sin 2551 
     - itemNumber
3064 chandransh 2552 
     - billed_by
4264 rajveer 2553 
     - jacketNumber
4283 anupam.sin 2554 
     - billingType
5110 mandeep.dh 2555 
     - fulfilmentWarehouseId
4763 rajveer 2556 
     - authorize
1135 chandransh 2557 
    """
5110 mandeep.dh 2558 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2559 
    return self.recv_addBillingDetails()
1135 chandransh 2560 
 
5110 mandeep.dh 2561 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2562 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2563 
    args = addBillingDetails_args()
2564 
    args.orderId = orderId
2565 
    args.invoice_number = invoice_number
4658 mandeep.dh 2566 
    args.serialNumber = serialNumber
4283 anupam.sin 2567 
    args.itemNumber = itemNumber
3064 chandransh 2568 
    args.billed_by = billed_by
4264 rajveer 2569 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2570 
    args.billingType = billingType
5110 mandeep.dh 2571 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2572 
    args.authorize = authorize
1135 chandransh 2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
3064 chandransh 2577 
  def recv_addBillingDetails(self, ):
1135 chandransh 2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
3064 chandransh 2584 
    result = addBillingDetails_result()
1135 chandransh 2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
3431 rajveer 2587 
    if result.success is not None:
3064 chandransh 2588 
      return result.success
3431 rajveer 2589 
    if result.ex is not None:
1135 chandransh 2590 
      raise result.ex
3064 chandransh 2591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2592 
 
4763 rajveer 2593 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2594 
    """
2595 
    Add the invoice number to the order.
2596 
 
2597 
    Parameters:
2598 
     - orderId
2599 
     - invoiceNumber
4763 rajveer 2600 
     - color
4579 rajveer 2601 
    """
4763 rajveer 2602 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2603 
    self.recv_addInvoiceNumber()
2604 
 
4763 rajveer 2605 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2606 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2607 
    args = addInvoiceNumber_args()
2608 
    args.orderId = orderId
2609 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2610 
    args.color = color
4579 rajveer 2611 
    args.write(self._oprot)
2612 
    self._oprot.writeMessageEnd()
2613 
    self._oprot.trans.flush()
2614 
 
2615 
  def recv_addInvoiceNumber(self, ):
2616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2617 
    if mtype == TMessageType.EXCEPTION:
2618 
      x = TApplicationException()
2619 
      x.read(self._iprot)
2620 
      self._iprot.readMessageEnd()
2621 
      raise x
2622 
    result = addInvoiceNumber_result()
2623 
    result.read(self._iprot)
2624 
    self._iprot.readMessageEnd()
2625 
    if result.ex is not None:
2626 
      raise result.ex
2627 
    return
2628 
 
4910 phani.kuma 2629 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2630 
    """
3064 chandransh 2631 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2632 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2633 
 
1408 ankur.sing 2634 
    Parameters:
3064 chandransh 2635 
     - warehouseId
1408 ankur.sing 2636 
     - providerId
3064 chandransh 2637 
     - cod
4910 phani.kuma 2638 
     - orderIds
1408 ankur.sing 2639 
    """
4910 phani.kuma 2640 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2641 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2642 
 
4910 phani.kuma 2643 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2644 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2645 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2646 
    args.warehouseId = warehouseId
1408 ankur.sing 2647 
    args.providerId = providerId
3064 chandransh 2648 
    args.cod = cod
4910 phani.kuma 2649 
    args.orderIds = orderIds
1408 ankur.sing 2650 
    args.write(self._oprot)
2651 
    self._oprot.writeMessageEnd()
2652 
    self._oprot.trans.flush()
2653 
 
4910 phani.kuma 2654 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2656 
    if mtype == TMessageType.EXCEPTION:
2657 
      x = TApplicationException()
2658 
      x.read(self._iprot)
2659 
      self._iprot.readMessageEnd()
2660 
      raise x
4910 phani.kuma 2661 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2662 
    result.read(self._iprot)
2663 
    self._iprot.readMessageEnd()
3431 rajveer 2664 
    if result.success is not None:
1408 ankur.sing 2665 
      return result.success
3431 rajveer 2666 
    if result.ex is not None:
3064 chandransh 2667 
      raise result.ex
4910 phani.kuma 2668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2669 
 
5713 rajveer 2670 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2671 
    """
2672 
    Parameters:
2673 
     - providerId
2674 
     - orderIds
5713 rajveer 2675 
     - awbs
5676 rajveer 2676 
    """
5713 rajveer 2677 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2678 
    return self.recv_markOrdersAsReturnedFromStore()
2679 
 
5713 rajveer 2680 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2681 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2682 
    args = markOrdersAsReturnedFromStore_args()
2683 
    args.providerId = providerId
2684 
    args.orderIds = orderIds
5713 rajveer 2685 
    args.awbs = awbs
5676 rajveer 2686 
    args.write(self._oprot)
2687 
    self._oprot.writeMessageEnd()
2688 
    self._oprot.trans.flush()
2689 
 
2690 
  def recv_markOrdersAsReturnedFromStore(self, ):
2691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2692 
    if mtype == TMessageType.EXCEPTION:
2693 
      x = TApplicationException()
2694 
      x.read(self._iprot)
2695 
      self._iprot.readMessageEnd()
2696 
      raise x
2697 
    result = markOrdersAsReturnedFromStore_result()
2698 
    result.read(self._iprot)
2699 
    self._iprot.readMessageEnd()
2700 
    if result.success is not None:
2701 
      return result.success
2702 
    if result.ex is not None:
2703 
      raise result.ex
2704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2705 
 
4910 phani.kuma 2706 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2707 
    """
4910 phani.kuma 2708 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2709 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2710 
 
2711 
    Parameters:
2712 
     - providerId
4910 phani.kuma 2713 
     - pickupDetails
4410 rajveer 2714 
    """
4910 phani.kuma 2715 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2716 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2717 
 
4910 phani.kuma 2718 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2719 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2720 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2721 
    args.providerId = providerId
4910 phani.kuma 2722 
    args.pickupDetails = pickupDetails
4410 rajveer 2723 
    args.write(self._oprot)
2724 
    self._oprot.writeMessageEnd()
2725 
    self._oprot.trans.flush()
2726 
 
4910 phani.kuma 2727 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2729 
    if mtype == TMessageType.EXCEPTION:
2730 
      x = TApplicationException()
2731 
      x.read(self._iprot)
2732 
      self._iprot.readMessageEnd()
2733 
      raise x
4910 phani.kuma 2734 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2735 
    result.read(self._iprot)
2736 
    self._iprot.readMessageEnd()
2737 
    if result.ex is not None:
2738 
      raise result.ex
4910 phani.kuma 2739 
    return
4410 rajveer 2740 
 
4910 phani.kuma 2741 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2742 
    """
3064 chandransh 2743 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2744 
 
94 ashish 2745 
    Parameters:
3064 chandransh 2746 
     - providerId
304 ashish 2747 
    """
4910 phani.kuma 2748 
    self.send_getOrdersNotPickedUp(providerId)
2749 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2750 
 
4910 phani.kuma 2751 
  def send_getOrdersNotPickedUp(self, providerId):
2752 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2753 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2754 
    args.providerId = providerId
304 ashish 2755 
    args.write(self._oprot)
2756 
    self._oprot.writeMessageEnd()
2757 
    self._oprot.trans.flush()
2758 
 
4910 phani.kuma 2759 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2761 
    if mtype == TMessageType.EXCEPTION:
2762 
      x = TApplicationException()
2763 
      x.read(self._iprot)
2764 
      self._iprot.readMessageEnd()
2765 
      raise x
4910 phani.kuma 2766 
    result = getOrdersNotPickedUp_result()
304 ashish 2767 
    result.read(self._iprot)
2768 
    self._iprot.readMessageEnd()
3431 rajveer 2769 
    if result.success is not None:
304 ashish 2770 
      return result.success
4910 phani.kuma 2771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2772 
 
3064 chandransh 2773 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2774 
    """
3064 chandransh 2775 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2776 
    the name of the receiver.
2777 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2778 
 
304 ashish 2779 
    Parameters:
3064 chandransh 2780 
     - providerId
2781 
     - deliveredOrders
304 ashish 2782 
    """
3064 chandransh 2783 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2784 
    self.recv_markOrdersAsDelivered()
304 ashish 2785 
 
3064 chandransh 2786 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2787 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2788 
    args = markOrdersAsDelivered_args()
2789 
    args.providerId = providerId
2790 
    args.deliveredOrders = deliveredOrders
304 ashish 2791 
    args.write(self._oprot)
2792 
    self._oprot.writeMessageEnd()
2793 
    self._oprot.trans.flush()
2794 
 
3064 chandransh 2795 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2797 
    if mtype == TMessageType.EXCEPTION:
2798 
      x = TApplicationException()
2799 
      x.read(self._iprot)
2800 
      self._iprot.readMessageEnd()
2801 
      raise x
3064 chandransh 2802 
    result = markOrdersAsDelivered_result()
304 ashish 2803 
    result.read(self._iprot)
2804 
    self._iprot.readMessageEnd()
3431 rajveer 2805 
    if result.ex is not None:
3064 chandransh 2806 
      raise result.ex
304 ashish 2807 
    return
2808 
 
4910 phani.kuma 2809 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2810 
    """
4910 phani.kuma 2811 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2812 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2813 
 
3064 chandransh 2814 
    Parameters:
2815 
     - providerId
2816 
     - returnedOrders
1596 ankur.sing 2817 
    """
4910 phani.kuma 2818 
    self.send_markAsRTOrders(providerId, returnedOrders)
2819 
    self.recv_markAsRTOrders()
304 ashish 2820 
 
4910 phani.kuma 2821 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2822 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2823 
    args = markAsRTOrders_args()
3064 chandransh 2824 
    args.providerId = providerId
2825 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2826 
    args.write(self._oprot)
2827 
    self._oprot.writeMessageEnd()
2828 
    self._oprot.trans.flush()
2829 
 
4910 phani.kuma 2830 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2832 
    if mtype == TMessageType.EXCEPTION:
2833 
      x = TApplicationException()
2834 
      x.read(self._iprot)
2835 
      self._iprot.readMessageEnd()
2836 
      raise x
4910 phani.kuma 2837 
    result = markAsRTOrders_result()
1596 ankur.sing 2838 
    result.read(self._iprot)
2839 
    self._iprot.readMessageEnd()
3431 rajveer 2840 
    if result.ex is not None:
3064 chandransh 2841 
      raise result.ex
2842 
    return
1596 ankur.sing 2843 
 
4910 phani.kuma 2844 
  def getRTOrders(self, providerId):
2845 
    """
2846 
    Returns a list of orders that were returned by courier.
2847 
 
2848 
    Parameters:
2849 
     - providerId
2850 
    """
2851 
    self.send_getRTOrders(providerId)
2852 
    return self.recv_getRTOrders()
2853 
 
2854 
  def send_getRTOrders(self, providerId):
2855 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2856 
    args = getRTOrders_args()
2857 
    args.providerId = providerId
2858 
    args.write(self._oprot)
2859 
    self._oprot.writeMessageEnd()
2860 
    self._oprot.trans.flush()
2861 
 
2862 
  def recv_getRTOrders(self, ):
2863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2864 
    if mtype == TMessageType.EXCEPTION:
2865 
      x = TApplicationException()
2866 
      x.read(self._iprot)
2867 
      self._iprot.readMessageEnd()
2868 
      raise x
2869 
    result = getRTOrders_result()
2870 
    result.read(self._iprot)
2871 
    self._iprot.readMessageEnd()
2872 
    if result.success is not None:
2873 
      return result.success
2874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2875 
 
3064 chandransh 2876 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2877 
    """
3064 chandransh 2878 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2879 
 
3064 chandransh 2880 
    Parameters:
2881 
     - providerId
2882 
     - undeliveredOrders
1627 ankur.sing 2883 
    """
3064 chandransh 2884 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2885 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2886 
 
3064 chandransh 2887 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2888 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2889 
    args = updateNonDeliveryReason_args()
2890 
    args.providerId = providerId
2891 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2892 
    args.write(self._oprot)
2893 
    self._oprot.writeMessageEnd()
2894 
    self._oprot.trans.flush()
2895 
 
3064 chandransh 2896 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2898 
    if mtype == TMessageType.EXCEPTION:
2899 
      x = TApplicationException()
2900 
      x.read(self._iprot)
2901 
      self._iprot.readMessageEnd()
2902 
      raise x
3064 chandransh 2903 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2904 
    result.read(self._iprot)
2905 
    self._iprot.readMessageEnd()
4910 phani.kuma 2906 
    if result.ex is not None:
2907 
      raise result.ex
2908 
    return
2909 
 
2910 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2911 
    """
2912 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2913 
 
2914 
    Parameters:
2915 
     - providerId
2916 
    """
2917 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2918 
    return self.recv_getNonDeliveredOrdersbyCourier()
2919 
 
2920 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2921 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2922 
    args = getNonDeliveredOrdersbyCourier_args()
2923 
    args.providerId = providerId
2924 
    args.write(self._oprot)
2925 
    self._oprot.writeMessageEnd()
2926 
    self._oprot.trans.flush()
2927 
 
2928 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2930 
    if mtype == TMessageType.EXCEPTION:
2931 
      x = TApplicationException()
2932 
      x.read(self._iprot)
2933 
      self._iprot.readMessageEnd()
2934 
      raise x
2935 
    result = getNonDeliveredOrdersbyCourier_result()
2936 
    result.read(self._iprot)
2937 
    self._iprot.readMessageEnd()
4581 phani.kuma 2938 
    if result.success is not None:
2939 
      return result.success
4910 phani.kuma 2940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2941 
 
2942 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2943 
    """
2944 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2945 
 
2946 
    Parameters:
2947 
     - providerId
2948 
     - local_connected_orders
2949 
    """
2950 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2951 
    self.recv_markOrdersAsLocalConnected()
2952 
 
2953 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2954 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2955 
    args = markOrdersAsLocalConnected_args()
2956 
    args.providerId = providerId
2957 
    args.local_connected_orders = local_connected_orders
2958 
    args.write(self._oprot)
2959 
    self._oprot.writeMessageEnd()
2960 
    self._oprot.trans.flush()
2961 
 
2962 
  def recv_markOrdersAsLocalConnected(self, ):
2963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2964 
    if mtype == TMessageType.EXCEPTION:
2965 
      x = TApplicationException()
2966 
      x.read(self._iprot)
2967 
      self._iprot.readMessageEnd()
2968 
      raise x
2969 
    result = markOrdersAsLocalConnected_result()
2970 
    result.read(self._iprot)
2971 
    self._iprot.readMessageEnd()
3431 rajveer 2972 
    if result.ex is not None:
3064 chandransh 2973 
      raise result.ex
4910 phani.kuma 2974 
    return
1627 ankur.sing 2975 
 
4910 phani.kuma 2976 
  def getOrdersNotLocalConnected(self, providerId):
2977 
    """
2978 
    Returns a list of orders that were picked up or shipped but pending local connection.
2979 
 
2980 
    Parameters:
2981 
     - providerId
2982 
    """
2983 
    self.send_getOrdersNotLocalConnected(providerId)
2984 
    return self.recv_getOrdersNotLocalConnected()
2985 
 
2986 
  def send_getOrdersNotLocalConnected(self, providerId):
2987 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2988 
    args = getOrdersNotLocalConnected_args()
2989 
    args.providerId = providerId
2990 
    args.write(self._oprot)
2991 
    self._oprot.writeMessageEnd()
2992 
    self._oprot.trans.flush()
2993 
 
2994 
  def recv_getOrdersNotLocalConnected(self, ):
2995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2996 
    if mtype == TMessageType.EXCEPTION:
2997 
      x = TApplicationException()
2998 
      x.read(self._iprot)
2999 
      self._iprot.readMessageEnd()
3000 
      raise x
3001 
    result = getOrdersNotLocalConnected_result()
3002 
    result.read(self._iprot)
3003 
    self._iprot.readMessageEnd()
3004 
    if result.success is not None:
3005 
      return result.success
3006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3007 
 
3008 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3009 
    """
3010 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3011 
 
3012 
    Parameters:
3013 
     - providerId
3014 
     - destination_city_reached_orders
3015 
    """
3016 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3017 
    self.recv_markOrdersAsDestinationCityReached()
3018 
 
3019 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3020 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3021 
    args = markOrdersAsDestinationCityReached_args()
3022 
    args.providerId = providerId
3023 
    args.destination_city_reached_orders = destination_city_reached_orders
3024 
    args.write(self._oprot)
3025 
    self._oprot.writeMessageEnd()
3026 
    self._oprot.trans.flush()
3027 
 
3028 
  def recv_markOrdersAsDestinationCityReached(self, ):
3029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3030 
    if mtype == TMessageType.EXCEPTION:
3031 
      x = TApplicationException()
3032 
      x.read(self._iprot)
3033 
      self._iprot.readMessageEnd()
3034 
      raise x
3035 
    result = markOrdersAsDestinationCityReached_result()
3036 
    result.read(self._iprot)
3037 
    self._iprot.readMessageEnd()
3038 
    if result.ex is not None:
3039 
      raise result.ex
3040 
    return
3041 
 
3042 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3043 
    """
3044 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3045 
 
3046 
    Parameters:
3047 
     - providerId
3048 
     - first_atdl_orders
3049 
    """
3050 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3051 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3052 
 
3053 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3054 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3055 
    args = markOrdersAsFirstDeliveryAttempted_args()
3056 
    args.providerId = providerId
3057 
    args.first_atdl_orders = first_atdl_orders
3058 
    args.write(self._oprot)
3059 
    self._oprot.writeMessageEnd()
3060 
    self._oprot.trans.flush()
3061 
 
3062 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3064 
    if mtype == TMessageType.EXCEPTION:
3065 
      x = TApplicationException()
3066 
      x.read(self._iprot)
3067 
      self._iprot.readMessageEnd()
3068 
      raise x
3069 
    result = markOrdersAsFirstDeliveryAttempted_result()
3070 
    result.read(self._iprot)
3071 
    self._iprot.readMessageEnd()
3072 
    if result.ex is not None:
3073 
      raise result.ex
3074 
    return
3075 
 
3064 chandransh 3076 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3077 
    """
3064 chandransh 3078 
    Returns the list of orders whose delivery time has passed but have not been
3079 
    delivered yet for the given provider and warehouse. To get a complete list of
3080 
    undelivered orders, pass them as -1.
3081 
    Returns an empty list if no such orders exist.
3431 rajveer 3082 
 
1886 ankur.sing 3083 
    Parameters:
3064 chandransh 3084 
     - providerId
3085 
     - warehouseId
1886 ankur.sing 3086 
    """
3064 chandransh 3087 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3088 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3089 
 
3064 chandransh 3090 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3091 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3092 
    args = getUndeliveredOrders_args()
3093 
    args.providerId = providerId
3094 
    args.warehouseId = warehouseId
1886 ankur.sing 3095 
    args.write(self._oprot)
3096 
    self._oprot.writeMessageEnd()
3097 
    self._oprot.trans.flush()
3098 
 
3064 chandransh 3099 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3101 
    if mtype == TMessageType.EXCEPTION:
3102 
      x = TApplicationException()
3103 
      x.read(self._iprot)
3104 
      self._iprot.readMessageEnd()
3105 
      raise x
3064 chandransh 3106 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3107 
    result.read(self._iprot)
3108 
    self._iprot.readMessageEnd()
3431 rajveer 3109 
    if result.success is not None:
1886 ankur.sing 3110 
      return result.success
3064 chandransh 3111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3112 
 
4783 phani.kuma 3113 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3114 
    """
3115 
    Returns the list of orders whose expected delivery date has passed but have not been
3116 
    delivered yet.
3117 
    Returns an empty list if no such orders exist.
3118 
    """
3119 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3120 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3121 
 
3122 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3123 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3124 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3125 
    args.write(self._oprot)
3126 
    self._oprot.writeMessageEnd()
3127 
    self._oprot.trans.flush()
3128 
 
3129 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3131 
    if mtype == TMessageType.EXCEPTION:
3132 
      x = TApplicationException()
3133 
      x.read(self._iprot)
3134 
      self._iprot.readMessageEnd()
3135 
      raise x
3136 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3137 
    result.read(self._iprot)
3138 
    self._iprot.readMessageEnd()
3139 
    if result.success is not None:
3140 
      return result.success
3141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3142 
 
2536 chandransh 3143 
  def toggleDOAFlag(self, orderId):
3144 
    """
3145 
    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.
3146 
    Returns the final flag status.
3147 
    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 3148 
 
2536 chandransh 3149 
    Parameters:
3150 
     - orderId
3151 
    """
3152 
    self.send_toggleDOAFlag(orderId)
3153 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3154 
 
2536 chandransh 3155 
  def send_toggleDOAFlag(self, orderId):
3156 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3157 
    args = toggleDOAFlag_args()
3158 
    args.orderId = orderId
3159 
    args.write(self._oprot)
3160 
    self._oprot.writeMessageEnd()
3161 
    self._oprot.trans.flush()
3162 
 
3163 
  def recv_toggleDOAFlag(self, ):
3164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3165 
    if mtype == TMessageType.EXCEPTION:
3166 
      x = TApplicationException()
3167 
      x.read(self._iprot)
3168 
      self._iprot.readMessageEnd()
3169 
      raise x
3170 
    result = toggleDOAFlag_result()
3171 
    result.read(self._iprot)
3172 
    self._iprot.readMessageEnd()
3431 rajveer 3173 
    if result.success is not None:
2536 chandransh 3174 
      return result.success
3431 rajveer 3175 
    if result.ex is not None:
2536 chandransh 3176 
      raise result.ex
3177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3178 
 
4712 rajveer 3179 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3180 
    """
3181 
    Parameters:
3182 
     - orderId
3183 
     - deliveryTimestamp
3184 
     - receiver
3185 
    """
3186 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3187 
    self.recv_markOrderAsDelivered()
3188 
 
3189 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3190 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3191 
    args = markOrderAsDelivered_args()
3192 
    args.orderId = orderId
3193 
    args.deliveryTimestamp = deliveryTimestamp
3194 
    args.receiver = receiver
3195 
    args.write(self._oprot)
3196 
    self._oprot.writeMessageEnd()
3197 
    self._oprot.trans.flush()
3198 
 
3199 
  def recv_markOrderAsDelivered(self, ):
3200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3201 
    if mtype == TMessageType.EXCEPTION:
3202 
      x = TApplicationException()
3203 
      x.read(self._iprot)
3204 
      self._iprot.readMessageEnd()
3205 
      raise x
3206 
    result = markOrderAsDelivered_result()
3207 
    result.read(self._iprot)
3208 
    self._iprot.readMessageEnd()
3209 
    if result.ex is not None:
3210 
      raise result.ex
3211 
    return
3212 
 
5553 rajveer 3213 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3214 
    """
3215 
    Parameters:
3216 
     - orderId
3217 
     - deliveryTimestamp
3218 
    """
3219 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3220 
    self.recv_markOrderAsReceivedAtStore()
3221 
 
3222 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3223 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3224 
    args = markOrderAsReceivedAtStore_args()
3225 
    args.orderId = orderId
3226 
    args.deliveryTimestamp = deliveryTimestamp
3227 
    args.write(self._oprot)
3228 
    self._oprot.writeMessageEnd()
3229 
    self._oprot.trans.flush()
3230 
 
3231 
  def recv_markOrderAsReceivedAtStore(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 = markOrderAsReceivedAtStore_result()
3239 
    result.read(self._iprot)
3240 
    self._iprot.readMessageEnd()
3241 
    if result.ex is not None:
3242 
      raise result.ex
3243 
    return
3244 
 
4454 rajveer 3245 
  def markOrderDoaRequestReceived(self, orderId):
3246 
    """
3247 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3248 
 
3249 
    Parameters:
3250 
     - orderId
3251 
    """
3252 
    self.send_markOrderDoaRequestReceived(orderId)
3253 
    return self.recv_markOrderDoaRequestReceived()
3254 
 
3255 
  def send_markOrderDoaRequestReceived(self, orderId):
3256 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3257 
    args = markOrderDoaRequestReceived_args()
3258 
    args.orderId = orderId
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_markOrderDoaRequestReceived(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = markOrderDoaRequestReceived_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.success is not None:
3274 
      return result.success
3275 
    if result.ex is not None:
3276 
      raise result.ex
3277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3278 
 
3279 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3280 
    """
3281 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3282 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3283 
 
3284 
    Parameters:
3285 
     - orderId
3286 
     - isAuthorized
3287 
    """
3288 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3289 
    return self.recv_markOrderDoaRequestAuthorized()
3290 
 
3291 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3292 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3293 
    args = markOrderDoaRequestAuthorized_args()
3294 
    args.orderId = orderId
3295 
    args.isAuthorized = isAuthorized
3296 
    args.write(self._oprot)
3297 
    self._oprot.writeMessageEnd()
3298 
    self._oprot.trans.flush()
3299 
 
3300 
  def recv_markOrderDoaRequestAuthorized(self, ):
3301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3302 
    if mtype == TMessageType.EXCEPTION:
3303 
      x = TApplicationException()
3304 
      x.read(self._iprot)
3305 
      self._iprot.readMessageEnd()
3306 
      raise x
3307 
    result = markOrderDoaRequestAuthorized_result()
3308 
    result.read(self._iprot)
3309 
    self._iprot.readMessageEnd()
3310 
    if result.success is not None:
3311 
      return result.success
3312 
    if result.ex is not None:
3313 
      raise result.ex
3314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3315 
 
4488 rajveer 3316 
  def markOrderReturnRequestReceived(self, orderId):
3317 
    """
3318 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3319 
 
3320 
    Parameters:
3321 
     - orderId
3322 
    """
3323 
    self.send_markOrderReturnRequestReceived(orderId)
3324 
    return self.recv_markOrderReturnRequestReceived()
3325 
 
3326 
  def send_markOrderReturnRequestReceived(self, orderId):
3327 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3328 
    args = markOrderReturnRequestReceived_args()
3329 
    args.orderId = orderId
3330 
    args.write(self._oprot)
3331 
    self._oprot.writeMessageEnd()
3332 
    self._oprot.trans.flush()
3333 
 
3334 
  def recv_markOrderReturnRequestReceived(self, ):
3335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3336 
    if mtype == TMessageType.EXCEPTION:
3337 
      x = TApplicationException()
3338 
      x.read(self._iprot)
3339 
      self._iprot.readMessageEnd()
3340 
      raise x
3341 
    result = markOrderReturnRequestReceived_result()
3342 
    result.read(self._iprot)
3343 
    self._iprot.readMessageEnd()
3344 
    if result.success is not None:
3345 
      return result.success
3346 
    if result.ex is not None:
3347 
      raise result.ex
3348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3349 
 
3350 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3351 
    """
3352 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3353 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3354 
 
3355 
    Parameters:
3356 
     - orderId
3357 
     - isAuthorized
3358 
    """
3359 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3360 
    return self.recv_markOrderReturnRequestAuthorized()
3361 
 
3362 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3363 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3364 
    args = markOrderReturnRequestAuthorized_args()
3365 
    args.orderId = orderId
3366 
    args.isAuthorized = isAuthorized
3367 
    args.write(self._oprot)
3368 
    self._oprot.writeMessageEnd()
3369 
    self._oprot.trans.flush()
3370 
 
3371 
  def recv_markOrderReturnRequestAuthorized(self, ):
3372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3373 
    if mtype == TMessageType.EXCEPTION:
3374 
      x = TApplicationException()
3375 
      x.read(self._iprot)
3376 
      self._iprot.readMessageEnd()
3377 
      raise x
3378 
    result = markOrderReturnRequestAuthorized_result()
3379 
    result.read(self._iprot)
3380 
    self._iprot.readMessageEnd()
3381 
    if result.success is not None:
3382 
      return result.success
3383 
    if result.ex is not None:
3384 
      raise result.ex
3385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3386 
 
4579 rajveer 3387 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3388 
    """
3389 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3390 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3391 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3392 
    For any other status, it returns false.
3393 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3394 
 
2536 chandransh 3395 
    Parameters:
3396 
     - orderId
4579 rajveer 3397 
     - providerId
2536 chandransh 3398 
    """
4579 rajveer 3399 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3400 
    return self.recv_requestPickupNumber()
3401 
 
4579 rajveer 3402 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3403 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3404 
    args = requestPickupNumber_args()
3405 
    args.orderId = orderId
4579 rajveer 3406 
    args.providerId = providerId
2536 chandransh 3407 
    args.write(self._oprot)
3408 
    self._oprot.writeMessageEnd()
3409 
    self._oprot.trans.flush()
3410 
 
3411 
  def recv_requestPickupNumber(self, ):
3412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3413 
    if mtype == TMessageType.EXCEPTION:
3414 
      x = TApplicationException()
3415 
      x.read(self._iprot)
3416 
      self._iprot.readMessageEnd()
3417 
      raise x
3418 
    result = requestPickupNumber_result()
3419 
    result.read(self._iprot)
3420 
    self._iprot.readMessageEnd()
3431 rajveer 3421 
    if result.success is not None:
2536 chandransh 3422 
      return result.success
3431 rajveer 3423 
    if result.ex is not None:
2536 chandransh 3424 
      raise result.ex
3425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3426 
 
4602 rajveer 3427 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3428 
    """
4452 rajveer 3429 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3430 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3431 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3432 
    	3. Returns true
2591 chandransh 3433 
    If the order is in any other status, it returns false.
2536 chandransh 3434 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3435 
 
2536 chandransh 3436 
    Parameters:
3437 
     - orderId
3438 
     - pickupNumber
4602 rajveer 3439 
     - providerId
2536 chandransh 3440 
    """
4602 rajveer 3441 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3442 
    return self.recv_authorizePickup()
3443 
 
4602 rajveer 3444 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3445 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3446 
    args = authorizePickup_args()
3447 
    args.orderId = orderId
3448 
    args.pickupNumber = pickupNumber
4602 rajveer 3449 
    args.providerId = providerId
2536 chandransh 3450 
    args.write(self._oprot)
3451 
    self._oprot.writeMessageEnd()
3452 
    self._oprot.trans.flush()
3453 
 
3454 
  def recv_authorizePickup(self, ):
3455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3456 
    if mtype == TMessageType.EXCEPTION:
3457 
      x = TApplicationException()
3458 
      x.read(self._iprot)
3459 
      self._iprot.readMessageEnd()
3460 
      raise x
3461 
    result = authorizePickup_result()
3462 
    result.read(self._iprot)
3463 
    self._iprot.readMessageEnd()
3431 rajveer 3464 
    if result.success is not None:
2536 chandransh 3465 
      return result.success
3431 rajveer 3466 
    if result.ex is not None:
2536 chandransh 3467 
      raise result.ex
3468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3469 
 
2764 chandransh 3470 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3471 
    """
3472 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3473 
 
2764 chandransh 3474 
    Parameters:
3475 
     - providerId
3476 
     - pickupDetails
3477 
    """
3478 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3479 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3480 
 
3481 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3482 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3483 
    args = markDoasAsPickedUp_args()
3484 
    args.providerId = providerId
3485 
    args.pickupDetails = pickupDetails
3486 
    args.write(self._oprot)
3487 
    self._oprot.writeMessageEnd()
3488 
    self._oprot.trans.flush()
3489 
 
3490 
  def recv_markDoasAsPickedUp(self, ):
3491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3492 
    if mtype == TMessageType.EXCEPTION:
3493 
      x = TApplicationException()
3494 
      x.read(self._iprot)
3495 
      self._iprot.readMessageEnd()
3496 
      raise x
3497 
    result = markDoasAsPickedUp_result()
3498 
    result.read(self._iprot)
3499 
    self._iprot.readMessageEnd()
4910 phani.kuma 3500 
    return
3501 
 
3502 
  def getDoasNotPickedUp(self, providerId):
3503 
    """
3504 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3505 
 
3506 
    Parameters:
3507 
     - providerId
3508 
    """
3509 
    self.send_getDoasNotPickedUp(providerId)
3510 
    return self.recv_getDoasNotPickedUp()
3511 
 
3512 
  def send_getDoasNotPickedUp(self, providerId):
3513 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3514 
    args = getDoasNotPickedUp_args()
3515 
    args.providerId = providerId
3516 
    args.write(self._oprot)
3517 
    self._oprot.writeMessageEnd()
3518 
    self._oprot.trans.flush()
3519 
 
3520 
  def recv_getDoasNotPickedUp(self, ):
3521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3522 
    if mtype == TMessageType.EXCEPTION:
3523 
      x = TApplicationException()
3524 
      x.read(self._iprot)
3525 
      self._iprot.readMessageEnd()
3526 
      raise x
3527 
    result = getDoasNotPickedUp_result()
3528 
    result.read(self._iprot)
3529 
    self._iprot.readMessageEnd()
3431 rajveer 3530 
    if result.success is not None:
2764 chandransh 3531 
      return result.success
4910 phani.kuma 3532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3533 
 
4741 phani.kuma 3534 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3535 
    """
3536 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3537 
 
3538 
    Parameters:
3539 
     - providerId
3540 
     - pickupDetails
3541 
    """
3542 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3543 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3544 
 
3545 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3546 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3547 
    args = markReturnOrdersAsPickedUp_args()
3548 
    args.providerId = providerId
3549 
    args.pickupDetails = pickupDetails
3550 
    args.write(self._oprot)
3551 
    self._oprot.writeMessageEnd()
3552 
    self._oprot.trans.flush()
3553 
 
3554 
  def recv_markReturnOrdersAsPickedUp(self, ):
3555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3556 
    if mtype == TMessageType.EXCEPTION:
3557 
      x = TApplicationException()
3558 
      x.read(self._iprot)
3559 
      self._iprot.readMessageEnd()
3560 
      raise x
3561 
    result = markReturnOrdersAsPickedUp_result()
3562 
    result.read(self._iprot)
3563 
    self._iprot.readMessageEnd()
4910 phani.kuma 3564 
    return
3565 
 
3566 
  def getReturnOrdersNotPickedUp(self, providerId):
3567 
    """
3568 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3569 
 
3570 
    Parameters:
3571 
     - providerId
3572 
    """
3573 
    self.send_getReturnOrdersNotPickedUp(providerId)
3574 
    return self.recv_getReturnOrdersNotPickedUp()
3575 
 
3576 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3577 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3578 
    args = getReturnOrdersNotPickedUp_args()
3579 
    args.providerId = providerId
3580 
    args.write(self._oprot)
3581 
    self._oprot.writeMessageEnd()
3582 
    self._oprot.trans.flush()
3583 
 
3584 
  def recv_getReturnOrdersNotPickedUp(self, ):
3585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3586 
    if mtype == TMessageType.EXCEPTION:
3587 
      x = TApplicationException()
3588 
      x.read(self._iprot)
3589 
      self._iprot.readMessageEnd()
3590 
      raise x
3591 
    result = getReturnOrdersNotPickedUp_result()
3592 
    result.read(self._iprot)
3593 
    self._iprot.readMessageEnd()
4741 phani.kuma 3594 
    if result.success is not None:
3595 
      return result.success
4910 phani.kuma 3596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3597 
 
4479 rajveer 3598 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3599 
    """
4452 rajveer 3600 
    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 3601 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3602 
    If the order is in any other state, it returns false.
3603 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3604 
 
2591 chandransh 3605 
    Parameters:
3606 
     - orderId
4479 rajveer 3607 
     - receiveCondition
2591 chandransh 3608 
    """
4479 rajveer 3609 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3610 
    return self.recv_receiveReturn()
2536 chandransh 3611 
 
4479 rajveer 3612 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3613 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3614 
    args = receiveReturn_args()
2591 chandransh 3615 
    args.orderId = orderId
4479 rajveer 3616 
    args.receiveCondition = receiveCondition
2591 chandransh 3617 
    args.write(self._oprot)
3618 
    self._oprot.writeMessageEnd()
3619 
    self._oprot.trans.flush()
3620 
 
2616 chandransh 3621 
  def recv_receiveReturn(self, ):
2591 chandransh 3622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3623 
    if mtype == TMessageType.EXCEPTION:
3624 
      x = TApplicationException()
3625 
      x.read(self._iprot)
3626 
      self._iprot.readMessageEnd()
3627 
      raise x
2616 chandransh 3628 
    result = receiveReturn_result()
2591 chandransh 3629 
    result.read(self._iprot)
3630 
    self._iprot.readMessageEnd()
3431 rajveer 3631 
    if result.success is not None:
2591 chandransh 3632 
      return result.success
3431 rajveer 3633 
    if result.ex is not None:
2591 chandransh 3634 
      raise result.ex
2616 chandransh 3635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3636 
 
3637 
  def validateDoa(self, orderId, isValid):
3638 
    """
4452 rajveer 3639 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3640 
    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 3641 
    If the order is in any other state, it returns false.
3642 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3643 
 
2591 chandransh 3644 
    Parameters:
3645 
     - orderId
3646 
     - isValid
3647 
    """
3648 
    self.send_validateDoa(orderId, isValid)
3649 
    return self.recv_validateDoa()
3650 
 
3651 
  def send_validateDoa(self, orderId, isValid):
3652 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3653 
    args = validateDoa_args()
3654 
    args.orderId = orderId
3655 
    args.isValid = isValid
3656 
    args.write(self._oprot)
3657 
    self._oprot.writeMessageEnd()
3658 
    self._oprot.trans.flush()
3659 
 
3660 
  def recv_validateDoa(self, ):
3661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3662 
    if mtype == TMessageType.EXCEPTION:
3663 
      x = TApplicationException()
3664 
      x.read(self._iprot)
3665 
      self._iprot.readMessageEnd()
3666 
      raise x
3667 
    result = validateDoa_result()
3668 
    result.read(self._iprot)
3669 
    self._iprot.readMessageEnd()
3431 rajveer 3670 
    if result.success is not None:
2591 chandransh 3671 
      return result.success
3431 rajveer 3672 
    if result.ex is not None:
2591 chandransh 3673 
      raise result.ex
3674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3675 
 
4495 rajveer 3676 
  def validateReturnProduct(self, orderId, isUsable):
3677 
    """
3678 
    Parameters:
3679 
     - orderId
3680 
     - isUsable
3681 
    """
3682 
    self.send_validateReturnProduct(orderId, isUsable)
3683 
    return self.recv_validateReturnProduct()
3684 
 
3685 
  def send_validateReturnProduct(self, orderId, isUsable):
3686 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3687 
    args = validateReturnProduct_args()
3688 
    args.orderId = orderId
3689 
    args.isUsable = isUsable
3690 
    args.write(self._oprot)
3691 
    self._oprot.writeMessageEnd()
3692 
    self._oprot.trans.flush()
3693 
 
3694 
  def recv_validateReturnProduct(self, ):
3695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3696 
    if mtype == TMessageType.EXCEPTION:
3697 
      x = TApplicationException()
3698 
      x.read(self._iprot)
3699 
      self._iprot.readMessageEnd()
3700 
      raise x
3701 
    result = validateReturnProduct_result()
3702 
    result.read(self._iprot)
3703 
    self._iprot.readMessageEnd()
3704 
    if result.success is not None:
3705 
      return result.success
3706 
    if result.ex is not None:
3707 
      raise result.ex
3708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3709 
 
2616 chandransh 3710 
  def reshipOrder(self, orderId):
3711 
    """
4484 rajveer 3712 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3713 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3714 
    	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 3715 
 
3716 
    If the order is in DOA_CERT_VALID state, it does the following:
3717 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3718 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3719 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3720 
 
2616 chandransh 3721 
    Returns the id of the newly created order.
3431 rajveer 3722 
 
2616 chandransh 3723 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3724 
 
2616 chandransh 3725 
    Parameters:
3726 
     - orderId
3727 
    """
3728 
    self.send_reshipOrder(orderId)
3729 
    return self.recv_reshipOrder()
2591 chandransh 3730 
 
2616 chandransh 3731 
  def send_reshipOrder(self, orderId):
3732 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3733 
    args = reshipOrder_args()
3734 
    args.orderId = orderId
3735 
    args.write(self._oprot)
3736 
    self._oprot.writeMessageEnd()
3737 
    self._oprot.trans.flush()
3738 
 
3739 
  def recv_reshipOrder(self, ):
3740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3741 
    if mtype == TMessageType.EXCEPTION:
3742 
      x = TApplicationException()
3743 
      x.read(self._iprot)
3744 
      self._iprot.readMessageEnd()
3745 
      raise x
3746 
    result = reshipOrder_result()
3747 
    result.read(self._iprot)
3748 
    self._iprot.readMessageEnd()
3431 rajveer 3749 
    if result.success is not None:
2616 chandransh 3750 
      return result.success
3431 rajveer 3751 
    if result.ex is not None:
2616 chandransh 3752 
      raise result.ex
3753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3754 
 
3226 chandransh 3755 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3756 
    """
4484 rajveer 3757 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3758 
    	1. Creates a refund request for batch processing.
3759 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3760 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3761 
 
2616 chandransh 3762 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3763 
    	1. Creates a refund request for batch processing.
3226 chandransh 3764 
    	2. Cancels the reservation of the item in the warehouse.
3765 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3766 
 
3226 chandransh 3767 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3768 
    	1. Cancels the reservation of the item in the warehouse.
3769 
    	2. Marks the current order as CANCELED.
3770 
 
3771 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3772 
 
2616 chandransh 3773 
    Returns True if it is successful, False otherwise.
3431 rajveer 3774 
 
2616 chandransh 3775 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3776 
 
2616 chandransh 3777 
    Parameters:
3778 
     - orderId
3226 chandransh 3779 
     - refundedBy
3780 
     - reason
2616 chandransh 3781 
    """
3226 chandransh 3782 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3783 
    return self.recv_refundOrder()
3784 
 
3226 chandransh 3785 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3786 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3787 
    args = refundOrder_args()
3788 
    args.orderId = orderId
3226 chandransh 3789 
    args.refundedBy = refundedBy
3790 
    args.reason = reason
2616 chandransh 3791 
    args.write(self._oprot)
3792 
    self._oprot.writeMessageEnd()
3793 
    self._oprot.trans.flush()
3794 
 
3795 
  def recv_refundOrder(self, ):
3796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3797 
    if mtype == TMessageType.EXCEPTION:
3798 
      x = TApplicationException()
3799 
      x.read(self._iprot)
3800 
      self._iprot.readMessageEnd()
3801 
      raise x
3802 
    result = refundOrder_result()
3803 
    result.read(self._iprot)
3804 
    self._iprot.readMessageEnd()
3431 rajveer 3805 
    if result.success is not None:
2616 chandransh 3806 
      return result.success
3431 rajveer 3807 
    if result.ex is not None:
2616 chandransh 3808 
      raise result.ex
3809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3810 
 
2690 chandransh 3811 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3812 
    """
3813 
    Get all return orders created between the from and to dates for the given warehouse.
3814 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3815 
 
2690 chandransh 3816 
    Parameters:
3817 
     - warehouseId
3818 
     - fromDate
3819 
     - toDate
3820 
    """
3821 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3822 
    return self.recv_getReturnOrders()
2616 chandransh 3823 
 
2690 chandransh 3824 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3825 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3826 
    args = getReturnOrders_args()
3827 
    args.warehouseId = warehouseId
3828 
    args.fromDate = fromDate
3829 
    args.toDate = toDate
3830 
    args.write(self._oprot)
3831 
    self._oprot.writeMessageEnd()
3832 
    self._oprot.trans.flush()
3833 
 
3834 
  def recv_getReturnOrders(self, ):
3835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3836 
    if mtype == TMessageType.EXCEPTION:
3837 
      x = TApplicationException()
3838 
      x.read(self._iprot)
3839 
      self._iprot.readMessageEnd()
3840 
      raise x
3841 
    result = getReturnOrders_result()
3842 
    result.read(self._iprot)
3843 
    self._iprot.readMessageEnd()
3431 rajveer 3844 
    if result.success is not None:
2690 chandransh 3845 
      return result.success
3846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3847 
 
5481 phani.kuma 3848 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3849 
    """
3850 
    Get all return orders created between the from and to dates.
3851 
 
3852 
    Parameters:
3853 
     - onlyNotProcessed
3854 
     - fromDate
3855 
     - toDate
3856 
    """
3857 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3858 
    return self.recv_getAllReturnOrders()
3859 
 
3860 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3861 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3862 
    args = getAllReturnOrders_args()
3863 
    args.onlyNotProcessed = onlyNotProcessed
3864 
    args.fromDate = fromDate
3865 
    args.toDate = toDate
3866 
    args.write(self._oprot)
3867 
    self._oprot.writeMessageEnd()
3868 
    self._oprot.trans.flush()
3869 
 
3870 
  def recv_getAllReturnOrders(self, ):
3871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3872 
    if mtype == TMessageType.EXCEPTION:
3873 
      x = TApplicationException()
3874 
      x.read(self._iprot)
3875 
      self._iprot.readMessageEnd()
3876 
      raise x
3877 
    result = getAllReturnOrders_result()
3878 
    result.read(self._iprot)
3879 
    self._iprot.readMessageEnd()
3880 
    if result.success is not None:
3881 
      return result.success
3882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3883 
 
2700 chandransh 3884 
  def getReturnOrder(self, id):
3885 
    """
3886 
    Returns the ReturnOrder corresponding to the given id.
3887 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3888 
 
2700 chandransh 3889 
    Parameters:
3890 
     - id
3891 
    """
3892 
    self.send_getReturnOrder(id)
3893 
    return self.recv_getReturnOrder()
3894 
 
3895 
  def send_getReturnOrder(self, id):
3896 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3897 
    args = getReturnOrder_args()
3898 
    args.id = id
3899 
    args.write(self._oprot)
3900 
    self._oprot.writeMessageEnd()
3901 
    self._oprot.trans.flush()
3902 
 
3903 
  def recv_getReturnOrder(self, ):
3904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3905 
    if mtype == TMessageType.EXCEPTION:
3906 
      x = TApplicationException()
3907 
      x.read(self._iprot)
3908 
      self._iprot.readMessageEnd()
3909 
      raise x
3910 
    result = getReturnOrder_result()
3911 
    result.read(self._iprot)
3912 
    self._iprot.readMessageEnd()
3431 rajveer 3913 
    if result.success is not None:
2700 chandransh 3914 
      return result.success
3431 rajveer 3915 
    if result.ex is not None:
2700 chandransh 3916 
      raise result.ex
3917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3918 
 
2690 chandransh 3919 
  def processReturn(self, returnOrderId):
3920 
    """
3921 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3922 
 
2690 chandransh 3923 
    Parameters:
3924 
     - returnOrderId
3925 
    """
3926 
    self.send_processReturn(returnOrderId)
3927 
    self.recv_processReturn()
3928 
 
3929 
  def send_processReturn(self, returnOrderId):
3930 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3931 
    args = processReturn_args()
3932 
    args.returnOrderId = returnOrderId
3933 
    args.write(self._oprot)
3934 
    self._oprot.writeMessageEnd()
3935 
    self._oprot.trans.flush()
3936 
 
3937 
  def recv_processReturn(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 = processReturn_result()
3945 
    result.read(self._iprot)
3946 
    self._iprot.readMessageEnd()
3431 rajveer 3947 
    if result.ex is not None:
2690 chandransh 3948 
      raise result.ex
3949 
    return
3950 
 
3451 chandransh 3951 
  def updateWeight(self, orderId, weight):
3952 
    """
3953 
    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 3954 
 
3451 chandransh 3955 
    Parameters:
3956 
     - orderId
3957 
     - weight
3958 
    """
3959 
    self.send_updateWeight(orderId, weight)
3960 
    return self.recv_updateWeight()
3961 
 
3962 
  def send_updateWeight(self, orderId, weight):
3963 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3964 
    args = updateWeight_args()
3965 
    args.orderId = orderId
3966 
    args.weight = weight
3967 
    args.write(self._oprot)
3968 
    self._oprot.writeMessageEnd()
3969 
    self._oprot.trans.flush()
3970 
 
3971 
  def recv_updateWeight(self, ):
3972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3973 
    if mtype == TMessageType.EXCEPTION:
3974 
      x = TApplicationException()
3975 
      x.read(self._iprot)
3976 
      self._iprot.readMessageEnd()
3977 
      raise x
3978 
    result = updateWeight_result()
3979 
    result.read(self._iprot)
3980 
    self._iprot.readMessageEnd()
3981 
    if result.success is not None:
3982 
      return result.success
3983 
    if result.ex is not None:
3984 
      raise result.ex
3985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3986 
 
3469 chandransh 3987 
  def changeItem(self, orderId, itemId):
3988 
    """
3989 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3990 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3991 
 
3469 chandransh 3992 
    Parameters:
3993 
     - orderId
3994 
     - itemId
3995 
    """
3996 
    self.send_changeItem(orderId, itemId)
3997 
    return self.recv_changeItem()
3998 
 
3999 
  def send_changeItem(self, orderId, itemId):
4000 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4001 
    args = changeItem_args()
4002 
    args.orderId = orderId
4003 
    args.itemId = itemId
4004 
    args.write(self._oprot)
4005 
    self._oprot.writeMessageEnd()
4006 
    self._oprot.trans.flush()
4007 
 
4008 
  def recv_changeItem(self, ):
4009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4010 
    if mtype == TMessageType.EXCEPTION:
4011 
      x = TApplicationException()
4012 
      x.read(self._iprot)
4013 
      self._iprot.readMessageEnd()
4014 
      raise x
4015 
    result = changeItem_result()
4016 
    result.read(self._iprot)
4017 
    self._iprot.readMessageEnd()
4018 
    if result.success is not None:
4019 
      return result.success
4020 
    if result.ex is not None:
4021 
      raise result.ex
4022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4023 
 
4024 
  def shiftToWarehouse(self, orderId, warehouseId):
4025 
    """
4026 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4027 
 
4028 
    Parameters:
4029 
     - orderId
4030 
     - warehouseId
4031 
    """
4032 
    self.send_shiftToWarehouse(orderId, warehouseId)
4033 
    return self.recv_shiftToWarehouse()
4034 
 
4035 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4036 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4037 
    args = shiftToWarehouse_args()
4038 
    args.orderId = orderId
4039 
    args.warehouseId = warehouseId
4040 
    args.write(self._oprot)
4041 
    self._oprot.writeMessageEnd()
4042 
    self._oprot.trans.flush()
4043 
 
4044 
  def recv_shiftToWarehouse(self, ):
4045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4046 
    if mtype == TMessageType.EXCEPTION:
4047 
      x = TApplicationException()
4048 
      x.read(self._iprot)
4049 
      self._iprot.readMessageEnd()
4050 
      raise x
4051 
    result = shiftToWarehouse_result()
4052 
    result.read(self._iprot)
4053 
    self._iprot.readMessageEnd()
4054 
    if result.success is not None:
4055 
      return result.success
4056 
    if result.ex is not None:
4057 
      raise result.ex
4058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4059 
 
4647 rajveer 4060 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4061 
    """
4062 
    Adds the given delay reason to the given order.
3986 chandransh 4063 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4064 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4065 
 
3553 chandransh 4066 
    Parameters:
4067 
     - orderId
4068 
     - delayReason
3986 chandransh 4069 
     - furtherDelay
4647 rajveer 4070 
     - delayReasonText
3553 chandransh 4071 
    """
4647 rajveer 4072 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4073 
    return self.recv_addDelayReason()
4074 
 
4647 rajveer 4075 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4076 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4077 
    args = addDelayReason_args()
4078 
    args.orderId = orderId
4079 
    args.delayReason = delayReason
3986 chandransh 4080 
    args.furtherDelay = furtherDelay
4647 rajveer 4081 
    args.delayReasonText = delayReasonText
3553 chandransh 4082 
    args.write(self._oprot)
4083 
    self._oprot.writeMessageEnd()
4084 
    self._oprot.trans.flush()
4085 
 
4086 
  def recv_addDelayReason(self, ):
4087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4088 
    if mtype == TMessageType.EXCEPTION:
4089 
      x = TApplicationException()
4090 
      x.read(self._iprot)
4091 
      self._iprot.readMessageEnd()
4092 
      raise x
4093 
    result = addDelayReason_result()
4094 
    result.read(self._iprot)
4095 
    self._iprot.readMessageEnd()
4096 
    if result.success is not None:
4097 
      return result.success
4098 
    if result.ex is not None:
4099 
      raise result.ex
4100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4101 
 
3956 chandransh 4102 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4103 
    """
4104 
    Marks the COD orders with given AWB nos. as having been processed.
4105 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4106 
 
3956 chandransh 4107 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4108 
    1. There is no order corresponding to an AWB number.
4109 
    2. The captured amount for a payment exceeds the total payment.
4110 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4111 
 
4112 
    Parameters:
4113 
     - collectedAmountMap
4114 
     - xferBy
4115 
     - xferTxnId
4116 
     - xferDate
4117 
    """
4118 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4119 
    return self.recv_reconcileCodCollection()
4120 
 
4121 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4122 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4123 
    args = reconcileCodCollection_args()
4124 
    args.collectedAmountMap = collectedAmountMap
4125 
    args.xferBy = xferBy
4126 
    args.xferTxnId = xferTxnId
4127 
    args.xferDate = xferDate
4128 
    args.write(self._oprot)
4129 
    self._oprot.writeMessageEnd()
4130 
    self._oprot.trans.flush()
4131 
 
4132 
  def recv_reconcileCodCollection(self, ):
4133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4134 
    if mtype == TMessageType.EXCEPTION:
4135 
      x = TApplicationException()
4136 
      x.read(self._iprot)
4137 
      self._iprot.readMessageEnd()
4138 
      raise x
4139 
    result = reconcileCodCollection_result()
4140 
    result.read(self._iprot)
4141 
    self._iprot.readMessageEnd()
4142 
    if result.success is not None:
4143 
      return result.success
4144 
    if result.ex is not None:
4145 
      raise result.ex
4146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4147 
 
4008 mandeep.dh 4148 
  def getTransactionsRequiringExtraProcessing(self, category):
4149 
    """
4065 mandeep.dh 4150 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4151 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4152 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4153 
 
4008 mandeep.dh 4154 
    Parameters:
4155 
     - category
4156 
    """
4157 
    self.send_getTransactionsRequiringExtraProcessing(category)
4158 
    return self.recv_getTransactionsRequiringExtraProcessing()
4159 
 
4160 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4161 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4162 
    args = getTransactionsRequiringExtraProcessing_args()
4163 
    args.category = category
4164 
    args.write(self._oprot)
4165 
    self._oprot.writeMessageEnd()
4166 
    self._oprot.trans.flush()
4167 
 
4168 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4170 
    if mtype == TMessageType.EXCEPTION:
4171 
      x = TApplicationException()
4172 
      x.read(self._iprot)
4173 
      self._iprot.readMessageEnd()
4174 
      raise x
4175 
    result = getTransactionsRequiringExtraProcessing_result()
4176 
    result.read(self._iprot)
4177 
    self._iprot.readMessageEnd()
4178 
    if result.success is not None:
4179 
      return result.success
4180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4181 
 
4182 
  def markTransactionAsProcessed(self, transactionId, category):
4183 
    """
4184 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4185 
    It essentially deletes the transaction id record for a particular
4186 
    processing type category (if present) from DB.
4187 
    This is currently used by CRM application.
4008 mandeep.dh 4188 
 
4189 
    Parameters:
4190 
     - transactionId
4191 
     - category
4192 
    """
4193 
    self.send_markTransactionAsProcessed(transactionId, category)
4194 
    self.recv_markTransactionAsProcessed()
4195 
 
4196 
  def send_markTransactionAsProcessed(self, transactionId, category):
4197 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4198 
    args = markTransactionAsProcessed_args()
4199 
    args.transactionId = transactionId
4200 
    args.category = category
4201 
    args.write(self._oprot)
4202 
    self._oprot.writeMessageEnd()
4203 
    self._oprot.trans.flush()
4204 
 
4205 
  def recv_markTransactionAsProcessed(self, ):
4206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4207 
    if mtype == TMessageType.EXCEPTION:
4208 
      x = TApplicationException()
4209 
      x.read(self._iprot)
4210 
      self._iprot.readMessageEnd()
4211 
      raise x
4212 
    result = markTransactionAsProcessed_result()
4213 
    result.read(self._iprot)
4214 
    self._iprot.readMessageEnd()
4215 
    return
4216 
 
4018 chandransh 4217 
  def getItemWiseRiskyOrdersCount(self, ):
4218 
    """
4219 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4220 
    is defined as one whose shipping date is about to expire.
4221 
    """
4222 
    self.send_getItemWiseRiskyOrdersCount()
4223 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4224 
 
4018 chandransh 4225 
  def send_getItemWiseRiskyOrdersCount(self, ):
4226 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4227 
    args = getItemWiseRiskyOrdersCount_args()
4228 
    args.write(self._oprot)
4229 
    self._oprot.writeMessageEnd()
4230 
    self._oprot.trans.flush()
4231 
 
4232 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4234 
    if mtype == TMessageType.EXCEPTION:
4235 
      x = TApplicationException()
4236 
      x.read(self._iprot)
4237 
      self._iprot.readMessageEnd()
4238 
      raise x
4239 
    result = getItemWiseRiskyOrdersCount_result()
4240 
    result.read(self._iprot)
4241 
    self._iprot.readMessageEnd()
4242 
    if result.success is not None:
4243 
      return result.success
4244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4245 
 
4295 varun.gupt 4246 
  def getOrdersForItemIds(self, itemIds):
4247 
    """
4248 
    Returns a list of all orders which have items with given id
4249 
 
4250 
    Parameters:
4251 
     - itemIds
4252 
    """
4253 
    self.send_getOrdersForItemIds(itemIds)
4254 
    return self.recv_getOrdersForItemIds()
4255 
 
4256 
  def send_getOrdersForItemIds(self, itemIds):
4257 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4258 
    args = getOrdersForItemIds_args()
4259 
    args.itemIds = itemIds
4260 
    args.write(self._oprot)
4261 
    self._oprot.writeMessageEnd()
4262 
    self._oprot.trans.flush()
4263 
 
4264 
  def recv_getOrdersForItemIds(self, ):
4265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4266 
    if mtype == TMessageType.EXCEPTION:
4267 
      x = TApplicationException()
4268 
      x.read(self._iprot)
4269 
      self._iprot.readMessageEnd()
4270 
      raise x
4271 
    result = getOrdersForItemIds_result()
4272 
    result.read(self._iprot)
4273 
    self._iprot.readMessageEnd()
4274 
    if result.success is not None:
4275 
      return result.success
4276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4277 
 
4247 rajveer 4278 
  def markOrderCancellationRequestReceived(self, orderId):
4279 
    """
4280 
    Mark order as cancellation request received. If customer sends request of cancellation of
4281 
    a particular order, this method will be called. It will just change status of the order
4282 
    depending on its current status. It also records the previous status, so that we can move
4283 
    back to that status if cancellation request is denied.
4018 chandransh 4284 
 
4247 rajveer 4285 
    Parameters:
4286 
     - orderId
4287 
    """
4288 
    self.send_markOrderCancellationRequestReceived(orderId)
4289 
    self.recv_markOrderCancellationRequestReceived()
4290 
 
4291 
  def send_markOrderCancellationRequestReceived(self, orderId):
4292 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4293 
    args = markOrderCancellationRequestReceived_args()
4294 
    args.orderId = orderId
4295 
    args.write(self._oprot)
4296 
    self._oprot.writeMessageEnd()
4297 
    self._oprot.trans.flush()
4298 
 
4299 
  def recv_markOrderCancellationRequestReceived(self, ):
4300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4301 
    if mtype == TMessageType.EXCEPTION:
4302 
      x = TApplicationException()
4303 
      x.read(self._iprot)
4304 
      self._iprot.readMessageEnd()
4305 
      raise x
4306 
    result = markOrderCancellationRequestReceived_result()
4307 
    result.read(self._iprot)
4308 
    self._iprot.readMessageEnd()
4309 
    if result.ex is not None:
4310 
      raise result.ex
4311 
    return
4312 
 
4313 
  def markOrderCancellationRequestConfirmed(self, orderId):
4314 
    """
4315 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4316 
    cancellation request confirmed. After this OM will be able to cancel the order.
4317 
 
4318 
    Parameters:
4319 
     - orderId
4320 
    """
4321 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4322 
    self.recv_markOrderCancellationRequestConfirmed()
4323 
 
4324 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4325 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4326 
    args = markOrderCancellationRequestConfirmed_args()
4327 
    args.orderId = orderId
4328 
    args.write(self._oprot)
4329 
    self._oprot.writeMessageEnd()
4330 
    self._oprot.trans.flush()
4331 
 
4332 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4334 
    if mtype == TMessageType.EXCEPTION:
4335 
      x = TApplicationException()
4336 
      x.read(self._iprot)
4337 
      self._iprot.readMessageEnd()
4338 
      raise x
4339 
    result = markOrderCancellationRequestConfirmed_result()
4340 
    result.read(self._iprot)
4341 
    self._iprot.readMessageEnd()
4342 
    if result.ex is not None:
4343 
      raise result.ex
4344 
    return
4345 
 
4346 
  def markOrderCancellationRequestDenied(self, orderId):
4347 
    """
4348 
    If we decide to not to cancel order, we will move the order ro previous status.
4349 
 
4350 
    Parameters:
4351 
     - orderId
4352 
    """
4353 
    self.send_markOrderCancellationRequestDenied(orderId)
4354 
    self.recv_markOrderCancellationRequestDenied()
4355 
 
4356 
  def send_markOrderCancellationRequestDenied(self, orderId):
4357 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4358 
    args = markOrderCancellationRequestDenied_args()
4359 
    args.orderId = orderId
4360 
    args.write(self._oprot)
4361 
    self._oprot.writeMessageEnd()
4362 
    self._oprot.trans.flush()
4363 
 
4364 
  def recv_markOrderCancellationRequestDenied(self, ):
4365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4366 
    if mtype == TMessageType.EXCEPTION:
4367 
      x = TApplicationException()
4368 
      x.read(self._iprot)
4369 
      self._iprot.readMessageEnd()
4370 
      raise x
4371 
    result = markOrderCancellationRequestDenied_result()
4372 
    result.read(self._iprot)
4373 
    self._iprot.readMessageEnd()
4374 
    if result.ex is not None:
4375 
      raise result.ex
4376 
    return
4377 
 
4258 rajveer 4378 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4379 
    """
4258 rajveer 4380 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4381 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4382 
 
4383 
    Parameters:
4258 rajveer 4384 
     - transactionId
4247 rajveer 4385 
    """
4258 rajveer 4386 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4387 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4388 
 
4258 rajveer 4389 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4390 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4391 
    args = markTransactionAsPaymentFlagRemoved_args()
4392 
    args.transactionId = transactionId
4247 rajveer 4393 
    args.write(self._oprot)
4394 
    self._oprot.writeMessageEnd()
4395 
    self._oprot.trans.flush()
4396 
 
4258 rajveer 4397 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4399 
    if mtype == TMessageType.EXCEPTION:
4400 
      x = TApplicationException()
4401 
      x.read(self._iprot)
4402 
      self._iprot.readMessageEnd()
4403 
      raise x
4258 rajveer 4404 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4405 
    result.read(self._iprot)
4406 
    self._iprot.readMessageEnd()
4407 
    if result.ex is not None:
4408 
      raise result.ex
4409 
    return
4410 
 
4259 anupam.sin 4411 
  def refundTransaction(self, transactionId, refundedBy, reason):
4412 
    """
4413 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4414 
    need to be cancelled
4247 rajveer 4415 
 
4259 anupam.sin 4416 
    Parameters:
4417 
     - transactionId
4418 
     - refundedBy
4419 
     - reason
4420 
    """
4421 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4422 
    self.recv_refundTransaction()
4423 
 
4424 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4425 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4426 
    args = refundTransaction_args()
4427 
    args.transactionId = transactionId
4428 
    args.refundedBy = refundedBy
4429 
    args.reason = reason
4430 
    args.write(self._oprot)
4431 
    self._oprot.writeMessageEnd()
4432 
    self._oprot.trans.flush()
4433 
 
4434 
  def recv_refundTransaction(self, ):
4435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4436 
    if mtype == TMessageType.EXCEPTION:
4437 
      x = TApplicationException()
4438 
      x.read(self._iprot)
4439 
      self._iprot.readMessageEnd()
4440 
      raise x
4441 
    result = refundTransaction_result()
4442 
    result.read(self._iprot)
4443 
    self._iprot.readMessageEnd()
4444 
    if result.ex is not None:
4445 
      raise result.ex
4446 
    return
4447 
 
4324 mandeep.dh 4448 
  def updateShipmentAddress(self, orderId, addressId):
4449 
    """
4450 
    Updates shipment address of an order. Delivery and shipping date estimates
4451 
    etc. are also updated here.
4452 
 
4453 
    Throws TransactionServiceException in case address change is not
4454 
    possible due to certain reasons such as new pincode in address is
4455 
    not serviceable etc.
4456 
 
4457 
    Parameters:
4458 
     - orderId
4459 
     - addressId
4460 
    """
4461 
    self.send_updateShipmentAddress(orderId, addressId)
4462 
    self.recv_updateShipmentAddress()
4463 
 
4464 
  def send_updateShipmentAddress(self, orderId, addressId):
4465 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4466 
    args = updateShipmentAddress_args()
4467 
    args.orderId = orderId
4468 
    args.addressId = addressId
4469 
    args.write(self._oprot)
4470 
    self._oprot.writeMessageEnd()
4471 
    self._oprot.trans.flush()
4472 
 
4473 
  def recv_updateShipmentAddress(self, ):
4474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4475 
    if mtype == TMessageType.EXCEPTION:
4476 
      x = TApplicationException()
4477 
      x.read(self._iprot)
4478 
      self._iprot.readMessageEnd()
4479 
      raise x
4480 
    result = updateShipmentAddress_result()
4481 
    result.read(self._iprot)
4482 
    self._iprot.readMessageEnd()
4483 
    if result.ex is not None:
4484 
      raise result.ex
4485 
    return
4486 
 
4285 rajveer 4487 
  def acceptOrdersForItemId(self, itemId, inventory):
4488 
    """
4489 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4490 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4491 
 
4285 rajveer 4492 
    Parameters:
4493 
     - itemId
4494 
     - inventory
4495 
    """
4496 
    self.send_acceptOrdersForItemId(itemId, inventory)
4497 
    return self.recv_acceptOrdersForItemId()
4498 
 
4499 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4500 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4501 
    args = acceptOrdersForItemId_args()
4502 
    args.itemId = itemId
4503 
    args.inventory = inventory
4504 
    args.write(self._oprot)
4505 
    self._oprot.writeMessageEnd()
4506 
    self._oprot.trans.flush()
4507 
 
4508 
  def recv_acceptOrdersForItemId(self, ):
4509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4510 
    if mtype == TMessageType.EXCEPTION:
4511 
      x = TApplicationException()
4512 
      x.read(self._iprot)
4513 
      self._iprot.readMessageEnd()
4514 
      raise x
4515 
    result = acceptOrdersForItemId_result()
4516 
    result.read(self._iprot)
4517 
    self._iprot.readMessageEnd()
4518 
    if result.success is not None:
4519 
      return result.success
4520 
    if result.ex is not None:
4521 
      raise result.ex
4522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4523 
 
4369 rajveer 4524 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4525 
    """
4526 
    Parameters:
4527 
     - vendorId
4528 
     - itemId
4529 
     - quantity
4530 
     - estimate
4369 rajveer 4531 
     - isReminder
4303 rajveer 4532 
    """
4369 rajveer 4533 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4534 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4535 
 
4369 rajveer 4536 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4537 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4538 
    args = markOrdersAsPORaised_args()
4539 
    args.vendorId = vendorId
4540 
    args.itemId = itemId
4541 
    args.quantity = quantity
4542 
    args.estimate = estimate
4369 rajveer 4543 
    args.isReminder = isReminder
4303 rajveer 4544 
    args.write(self._oprot)
4545 
    self._oprot.writeMessageEnd()
4546 
    self._oprot.trans.flush()
4547 
 
4548 
  def recv_markOrdersAsPORaised(self, ):
4549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4550 
    if mtype == TMessageType.EXCEPTION:
4551 
      x = TApplicationException()
4552 
      x.read(self._iprot)
4553 
      self._iprot.readMessageEnd()
4554 
      raise x
4555 
    result = markOrdersAsPORaised_result()
4556 
    result.read(self._iprot)
4557 
    self._iprot.readMessageEnd()
4558 
    if result.ex is not None:
4559 
      raise result.ex
4560 
    return
4561 
 
4369 rajveer 4562 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4563 
    """
4564 
    Parameters:
4565 
     - vendorId
4566 
     - itemId
4567 
     - quantity
4568 
     - estimate
4369 rajveer 4569 
     - isReminder
4303 rajveer 4570 
    """
4369 rajveer 4571 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4572 
    self.recv_markOrdersAsReversalInitiated()
4573 
 
4369 rajveer 4574 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4575 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4576 
    args = markOrdersAsReversalInitiated_args()
4577 
    args.vendorId = vendorId
4578 
    args.itemId = itemId
4579 
    args.quantity = quantity
4580 
    args.estimate = estimate
4369 rajveer 4581 
    args.isReminder = isReminder
4303 rajveer 4582 
    args.write(self._oprot)
4583 
    self._oprot.writeMessageEnd()
4584 
    self._oprot.trans.flush()
4585 
 
4586 
  def recv_markOrdersAsReversalInitiated(self, ):
4587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4588 
    if mtype == TMessageType.EXCEPTION:
4589 
      x = TApplicationException()
4590 
      x.read(self._iprot)
4591 
      self._iprot.readMessageEnd()
4592 
      raise x
4593 
    result = markOrdersAsReversalInitiated_result()
4594 
    result.read(self._iprot)
4595 
    self._iprot.readMessageEnd()
4596 
    if result.ex is not None:
4597 
      raise result.ex
4598 
    return
4599 
 
4369 rajveer 4600 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4601 
    """
4602 
    Parameters:
4603 
     - vendorId
4604 
     - itemId
4605 
     - quantity
4606 
     - estimate
4369 rajveer 4607 
     - isReminder
4303 rajveer 4608 
    """
4369 rajveer 4609 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4610 
    self.recv_markOrdersAsNotAvailabke()
4611 
 
4369 rajveer 4612 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4613 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4614 
    args = markOrdersAsNotAvailabke_args()
4615 
    args.vendorId = vendorId
4616 
    args.itemId = itemId
4617 
    args.quantity = quantity
4618 
    args.estimate = estimate
4369 rajveer 4619 
    args.isReminder = isReminder
4303 rajveer 4620 
    args.write(self._oprot)
4621 
    self._oprot.writeMessageEnd()
4622 
    self._oprot.trans.flush()
4623 
 
4624 
  def recv_markOrdersAsNotAvailabke(self, ):
4625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4626 
    if mtype == TMessageType.EXCEPTION:
4627 
      x = TApplicationException()
4628 
      x.read(self._iprot)
4629 
      self._iprot.readMessageEnd()
4630 
      raise x
4631 
    result = markOrdersAsNotAvailabke_result()
4632 
    result.read(self._iprot)
4633 
    self._iprot.readMessageEnd()
4634 
    if result.ex is not None:
4635 
      raise result.ex
4636 
    return
4637 
 
4369 rajveer 4638 
  def markOrdersAsTimeout(self, vendorId):
4639 
    """
4640 
    Parameters:
4641 
     - vendorId
4642 
    """
4643 
    self.send_markOrdersAsTimeout(vendorId)
4644 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4645 
 
4369 rajveer 4646 
  def send_markOrdersAsTimeout(self, vendorId):
4647 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4648 
    args = markOrdersAsTimeout_args()
4649 
    args.vendorId = vendorId
4650 
    args.write(self._oprot)
4651 
    self._oprot.writeMessageEnd()
4652 
    self._oprot.trans.flush()
4653 
 
4654 
  def recv_markOrdersAsTimeout(self, ):
4655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4656 
    if mtype == TMessageType.EXCEPTION:
4657 
      x = TApplicationException()
4658 
      x.read(self._iprot)
4659 
      self._iprot.readMessageEnd()
4660 
      raise x
4661 
    result = markOrdersAsTimeout_result()
4662 
    result.read(self._iprot)
4663 
    self._iprot.readMessageEnd()
4664 
    if result.success is not None:
4665 
      return result.success
4666 
    if result.ex is not None:
4667 
      raise result.ex
4668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4669 
 
4662 rajveer 4670 
  def markOrderAsLostInTransit(self, orderId):
4671 
    """
4672 
    Mark order as LOST_IN_TRANSIT
4673 
 
4674 
    Parameters:
4675 
     - orderId
4676 
    """
4677 
    self.send_markOrderAsLostInTransit(orderId)
4678 
    return self.recv_markOrderAsLostInTransit()
4679 
 
4680 
  def send_markOrderAsLostInTransit(self, orderId):
4681 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4682 
    args = markOrderAsLostInTransit_args()
4683 
    args.orderId = orderId
4684 
    args.write(self._oprot)
4685 
    self._oprot.writeMessageEnd()
4686 
    self._oprot.trans.flush()
4687 
 
4688 
  def recv_markOrderAsLostInTransit(self, ):
4689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4690 
    if mtype == TMessageType.EXCEPTION:
4691 
      x = TApplicationException()
4692 
      x.read(self._iprot)
4693 
      self._iprot.readMessageEnd()
4694 
      raise x
4695 
    result = markOrderAsLostInTransit_result()
4696 
    result.read(self._iprot)
4697 
    self._iprot.readMessageEnd()
4698 
    if result.success is not None:
4699 
      return result.success
4700 
    if result.ex is not None:
4701 
      raise result.ex
4702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4703 
 
4386 anupam.sin 4704 
  def getOrderForAwb(self, awb):
4705 
    """
4706 
    Returns the order corresponding to an AWB number
4369 rajveer 4707 
 
4386 anupam.sin 4708 
    Parameters:
4709 
     - awb
4710 
    """
4711 
    self.send_getOrderForAwb(awb)
4712 
    return self.recv_getOrderForAwb()
4713 
 
4714 
  def send_getOrderForAwb(self, awb):
4715 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4716 
    args = getOrderForAwb_args()
4717 
    args.awb = awb
4718 
    args.write(self._oprot)
4719 
    self._oprot.writeMessageEnd()
4720 
    self._oprot.trans.flush()
4721 
 
4722 
  def recv_getOrderForAwb(self, ):
4723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4724 
    if mtype == TMessageType.EXCEPTION:
4725 
      x = TApplicationException()
4726 
      x.read(self._iprot)
4727 
      self._iprot.readMessageEnd()
4728 
      raise x
4729 
    result = getOrderForAwb_result()
4730 
    result.read(self._iprot)
4731 
    self._iprot.readMessageEnd()
4732 
    if result.success is not None:
4733 
      return result.success
4734 
    if result.ex is not None:
4735 
      raise result.ex
4736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4737 
 
4910 phani.kuma 4738 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4739 
    """
4910 phani.kuma 4740 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4741 
 
4506 phani.kuma 4742 
    Parameters:
4743 
     - logistics_provider_id
4910 phani.kuma 4744 
     - order_status_list
4506 phani.kuma 4745 
    """
4910 phani.kuma 4746 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4747 
    return self.recv_getOrdersForProviderForStatus()
4748 
 
4910 phani.kuma 4749 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4750 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4751 
    args = getOrdersForProviderForStatus_args()
4752 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4753 
    args.order_status_list = order_status_list
4506 phani.kuma 4754 
    args.write(self._oprot)
4755 
    self._oprot.writeMessageEnd()
4756 
    self._oprot.trans.flush()
4757 
 
4758 
  def recv_getOrdersForProviderForStatus(self, ):
4759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4760 
    if mtype == TMessageType.EXCEPTION:
4761 
      x = TApplicationException()
4762 
      x.read(self._iprot)
4763 
      self._iprot.readMessageEnd()
4764 
      raise x
4765 
    result = getOrdersForProviderForStatus_result()
4766 
    result.read(self._iprot)
4767 
    self._iprot.readMessageEnd()
4768 
    if result.success is not None:
4769 
      return result.success
4770 
    if result.ex is not None:
4771 
      raise result.ex
4772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4773 
 
4600 varun.gupt 4774 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4775 
    """
4776 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4777 
 
4600 varun.gupt 4778 
    Parameters:
4779 
     - vendorId
4780 
     - billingDateFrom
4781 
     - billingDateTo
4782 
    """
4783 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4784 
    return self.recv_getBilledOrdersForVendor()
4785 
 
4786 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4787 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4788 
    args = getBilledOrdersForVendor_args()
4789 
    args.vendorId = vendorId
4790 
    args.billingDateFrom = billingDateFrom
4791 
    args.billingDateTo = billingDateTo
4792 
    args.write(self._oprot)
4793 
    self._oprot.writeMessageEnd()
4794 
    self._oprot.trans.flush()
4795 
 
4796 
  def recv_getBilledOrdersForVendor(self, ):
4797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4798 
    if mtype == TMessageType.EXCEPTION:
4799 
      x = TApplicationException()
4800 
      x.read(self._iprot)
4801 
      self._iprot.readMessageEnd()
4802 
      raise x
4803 
    result = getBilledOrdersForVendor_result()
4804 
    result.read(self._iprot)
4805 
    self._iprot.readMessageEnd()
4806 
    if result.success is not None:
4807 
      return result.success
4808 
    if result.ex is not None:
4809 
      raise result.ex
4810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4811 
 
4607 rajveer 4812 
  def getSlippedSippingDateOrders(self, ):
4813 
    self.send_getSlippedSippingDateOrders()
4814 
    return self.recv_getSlippedSippingDateOrders()
4815 
 
4816 
  def send_getSlippedSippingDateOrders(self, ):
4817 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4818 
    args = getSlippedSippingDateOrders_args()
4819 
    args.write(self._oprot)
4820 
    self._oprot.writeMessageEnd()
4821 
    self._oprot.trans.flush()
4822 
 
4823 
  def recv_getSlippedSippingDateOrders(self, ):
4824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4825 
    if mtype == TMessageType.EXCEPTION:
4826 
      x = TApplicationException()
4827 
      x.read(self._iprot)
4828 
      self._iprot.readMessageEnd()
4829 
      raise x
4830 
    result = getSlippedSippingDateOrders_result()
4831 
    result.read(self._iprot)
4832 
    self._iprot.readMessageEnd()
4833 
    if result.success is not None:
4834 
      return result.success
4835 
    if result.ex is not None:
4836 
      raise result.ex
4837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4838 
 
4709 rajveer 4839 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4840 
    """
4841 
    Parameters:
4842 
     - cancelDateFrom
4843 
     - cancelDateTo
4844 
    """
4845 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4846 
    return self.recv_getCancelledOrders()
4847 
 
4848 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4849 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4850 
    args = getCancelledOrders_args()
4851 
    args.cancelDateFrom = cancelDateFrom
4852 
    args.cancelDateTo = cancelDateTo
4853 
    args.write(self._oprot)
4854 
    self._oprot.writeMessageEnd()
4855 
    self._oprot.trans.flush()
4856 
 
4857 
  def recv_getCancelledOrders(self, ):
4858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4859 
    if mtype == TMessageType.EXCEPTION:
4860 
      x = TApplicationException()
4861 
      x.read(self._iprot)
4862 
      self._iprot.readMessageEnd()
4863 
      raise x
4864 
    result = getCancelledOrders_result()
4865 
    result.read(self._iprot)
4866 
    self._iprot.readMessageEnd()
4867 
    if result.success is not None:
4868 
      return result.success
4869 
    if result.ex is not None:
4870 
      raise result.ex
4871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4872 
 
4600 varun.gupt 4873 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4874 
    """
4875 
    Parameters:
4876 
     - mapAWBAndAmount
4877 
    """
4878 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4879 
    self.recv_saveBluedartSettlements()
4880 
 
4881 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4882 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4883 
    args = saveBluedartSettlements_args()
4884 
    args.mapAWBAndAmount = mapAWBAndAmount
4885 
    args.write(self._oprot)
4886 
    self._oprot.writeMessageEnd()
4887 
    self._oprot.trans.flush()
4888 
 
4889 
  def recv_saveBluedartSettlements(self, ):
4890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4891 
    if mtype == TMessageType.EXCEPTION:
4892 
      x = TApplicationException()
4893 
      x.read(self._iprot)
4894 
      self._iprot.readMessageEnd()
4895 
      raise x
4896 
    result = saveBluedartSettlements_result()
4897 
    result.read(self._iprot)
4898 
    self._iprot.readMessageEnd()
4899 
    if result.ex is not None:
4900 
      raise result.ex
4901 
    return
4902 
 
4905 varun.gupt 4903 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4904 
    """
4905 
    Parameters:
4906 
     - settlementDate
4907 
     - paymentGatewayId
4905 varun.gupt 4908 
     - referenceId
4600 varun.gupt 4909 
     - serviceTax
4910 
     - otherCharges
4911 
     - netCollection
4912 
    """
4905 varun.gupt 4913 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4914 
    self.recv_savePaymentSettlements()
4915 
 
4905 varun.gupt 4916 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4917 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4918 
    args = savePaymentSettlements_args()
4919 
    args.settlementDate = settlementDate
4920 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4921 
    args.referenceId = referenceId
4600 varun.gupt 4922 
    args.serviceTax = serviceTax
4923 
    args.otherCharges = otherCharges
4924 
    args.netCollection = netCollection
4925 
    args.write(self._oprot)
4926 
    self._oprot.writeMessageEnd()
4927 
    self._oprot.trans.flush()
4928 
 
4929 
  def recv_savePaymentSettlements(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 = savePaymentSettlements_result()
4937 
    result.read(self._iprot)
4938 
    self._iprot.readMessageEnd()
4939 
    if result.ex is not None:
4940 
      raise result.ex
4941 
    return
4942 
 
4943 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4944 
    """
4945 
    Parameters:
4946 
     - settlementId
4947 
     - settlementDate
4948 
     - transactionDateFrom
4949 
     - transactionDateTo
4950 
     - amount
4951 
    """
4952 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4953 
    self.recv_saveEBSSettlementSummary()
4954 
 
4955 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4956 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4957 
    args = saveEBSSettlementSummary_args()
4958 
    args.settlementId = settlementId
4959 
    args.settlementDate = settlementDate
4960 
    args.transactionDateFrom = transactionDateFrom
4961 
    args.transactionDateTo = transactionDateTo
4962 
    args.amount = amount
4963 
    args.write(self._oprot)
4964 
    self._oprot.writeMessageEnd()
4965 
    self._oprot.trans.flush()
4966 
 
4967 
  def recv_saveEBSSettlementSummary(self, ):
4968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4969 
    if mtype == TMessageType.EXCEPTION:
4970 
      x = TApplicationException()
4971 
      x.read(self._iprot)
4972 
      self._iprot.readMessageEnd()
4973 
      raise x
4974 
    result = saveEBSSettlementSummary_result()
4975 
    result.read(self._iprot)
4976 
    self._iprot.readMessageEnd()
4977 
    if result.ex is not None:
4978 
      raise result.ex
4979 
    return
4980 
 
5386 phani.kuma 4981 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4982 
    """
4983 
    Parameters:
5189 varun.gupt 4984 
     - referenceId
4985 
     - isRefund
4600 varun.gupt 4986 
    """
5386 phani.kuma 4987 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4988 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4989 
 
5386 phani.kuma 4990 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4991 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4992 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4993 
    args.referenceId = referenceId
4994 
    args.isRefund = isRefund
4600 varun.gupt 4995 
    args.write(self._oprot)
4996 
    self._oprot.writeMessageEnd()
4997 
    self._oprot.trans.flush()
4998 
 
5386 phani.kuma 4999 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 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
5386 phani.kuma 5006 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 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
5386 phani.kuma 5013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5014 
 
5386 phani.kuma 5015 
  def getSettlementForCod(self, orderId, isRefund):
5016 
    """
5017 
    Parameters:
5018 
     - orderId
5019 
     - isRefund
5020 
    """
5021 
    self.send_getSettlementForCod(orderId, isRefund)
5022 
    return self.recv_getSettlementForCod()
5023 
 
5024 
  def send_getSettlementForCod(self, orderId, isRefund):
5025 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5026 
    args = getSettlementForCod_args()
5027 
    args.orderId = orderId
5028 
    args.isRefund = isRefund
5029 
    args.write(self._oprot)
5030 
    self._oprot.writeMessageEnd()
5031 
    self._oprot.trans.flush()
5032 
 
5033 
  def recv_getSettlementForCod(self, ):
5034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5035 
    if mtype == TMessageType.EXCEPTION:
5036 
      x = TApplicationException()
5037 
      x.read(self._iprot)
5038 
      self._iprot.readMessageEnd()
5039 
      raise x
5040 
    result = getSettlementForCod_result()
5041 
    result.read(self._iprot)
5042 
    self._iprot.readMessageEnd()
5043 
    if result.success is not None:
5044 
      return result.success
5045 
    if result.ex is not None:
5046 
      raise result.ex
5047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5048 
 
4600 varun.gupt 5049 
  def getEBSSettlementSummaries(self, ):
5050 
    self.send_getEBSSettlementSummaries()
5051 
    return self.recv_getEBSSettlementSummaries()
5052 
 
5053 
  def send_getEBSSettlementSummaries(self, ):
5054 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5055 
    args = getEBSSettlementSummaries_args()
5056 
    args.write(self._oprot)
5057 
    self._oprot.writeMessageEnd()
5058 
    self._oprot.trans.flush()
5059 
 
5060 
  def recv_getEBSSettlementSummaries(self, ):
5061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5062 
    if mtype == TMessageType.EXCEPTION:
5063 
      x = TApplicationException()
5064 
      x.read(self._iprot)
5065 
      self._iprot.readMessageEnd()
5066 
      raise x
5067 
    result = getEBSSettlementSummaries_result()
5068 
    result.read(self._iprot)
5069 
    self._iprot.readMessageEnd()
5070 
    if result.success is not None:
5071 
      return result.success
5072 
    if result.ex is not None:
5073 
      raise result.ex
5074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5075 
 
5076 
  def markEBSSettlementUploaded(self, settlementId):
5077 
    """
5078 
    Parameters:
5079 
     - settlementId
5080 
    """
5081 
    self.send_markEBSSettlementUploaded(settlementId)
5082 
    self.recv_markEBSSettlementUploaded()
5083 
 
5084 
  def send_markEBSSettlementUploaded(self, settlementId):
5085 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5086 
    args = markEBSSettlementUploaded_args()
5087 
    args.settlementId = settlementId
5088 
    args.write(self._oprot)
5089 
    self._oprot.writeMessageEnd()
5090 
    self._oprot.trans.flush()
5091 
 
5092 
  def recv_markEBSSettlementUploaded(self, ):
5093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5094 
    if mtype == TMessageType.EXCEPTION:
5095 
      x = TApplicationException()
5096 
      x.read(self._iprot)
5097 
      self._iprot.readMessageEnd()
5098 
      raise x
5099 
    result = markEBSSettlementUploaded_result()
5100 
    result.read(self._iprot)
5101 
    self._iprot.readMessageEnd()
5102 
    if result.ex is not None:
5103 
      raise result.ex
5104 
    return
5105 
 
5106 
  def getEBSSettlementDate(self, settlementId):
5107 
    """
5108 
    Parameters:
5109 
     - settlementId
5110 
    """
5111 
    self.send_getEBSSettlementDate(settlementId)
5112 
    return self.recv_getEBSSettlementDate()
5113 
 
5114 
  def send_getEBSSettlementDate(self, settlementId):
5115 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5116 
    args = getEBSSettlementDate_args()
5117 
    args.settlementId = settlementId
5118 
    args.write(self._oprot)
5119 
    self._oprot.writeMessageEnd()
5120 
    self._oprot.trans.flush()
5121 
 
5122 
  def recv_getEBSSettlementDate(self, ):
5123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5124 
    if mtype == TMessageType.EXCEPTION:
5125 
      x = TApplicationException()
5126 
      x.read(self._iprot)
5127 
      self._iprot.readMessageEnd()
5128 
      raise x
5129 
    result = getEBSSettlementDate_result()
5130 
    result.read(self._iprot)
5131 
    self._iprot.readMessageEnd()
5132 
    if result.success is not None:
5133 
      return result.success
5134 
    if result.ex is not None:
5135 
      raise result.ex
5136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5137 
 
4715 varun.gupt 5138 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5139 
    """
5140 
    Parameters:
5141 
     - settlementDateFrom
5142 
     - settlementDateTo
5143 
     - isRefund
5144 
    """
5145 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5146 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5147 
 
4715 varun.gupt 5148 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5149 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5150 
    args = getSettlementsByDate_args()
5151 
    args.settlementDateFrom = settlementDateFrom
5152 
    args.settlementDateTo = settlementDateTo
5153 
    args.isRefund = isRefund
5154 
    args.write(self._oprot)
5155 
    self._oprot.writeMessageEnd()
5156 
    self._oprot.trans.flush()
5157 
 
5158 
  def recv_getSettlementsByDate(self, ):
5159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5160 
    if mtype == TMessageType.EXCEPTION:
5161 
      x = TApplicationException()
5162 
      x.read(self._iprot)
5163 
      self._iprot.readMessageEnd()
5164 
      raise x
5165 
    result = getSettlementsByDate_result()
5166 
    result.read(self._iprot)
5167 
    self._iprot.readMessageEnd()
5168 
    if result.success is not None:
5169 
      return result.success
5170 
    if result.ex is not None:
5171 
      raise result.ex
5172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5173 
 
5174 
  def getReshippedOrderIds(self, orderIds):
5175 
    """
5176 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5177 
 
5178 
    Parameters:
5179 
     - orderIds
5180 
    """
5181 
    self.send_getReshippedOrderIds(orderIds)
5182 
    return self.recv_getReshippedOrderIds()
5183 
 
5184 
  def send_getReshippedOrderIds(self, orderIds):
5185 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5186 
    args = getReshippedOrderIds_args()
5187 
    args.orderIds = orderIds
5188 
    args.write(self._oprot)
5189 
    self._oprot.writeMessageEnd()
5190 
    self._oprot.trans.flush()
5191 
 
5192 
  def recv_getReshippedOrderIds(self, ):
5193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5194 
    if mtype == TMessageType.EXCEPTION:
5195 
      x = TApplicationException()
5196 
      x.read(self._iprot)
5197 
      self._iprot.readMessageEnd()
5198 
      raise x
5199 
    result = getReshippedOrderIds_result()
5200 
    result.read(self._iprot)
5201 
    self._iprot.readMessageEnd()
5202 
    if result.success is not None:
5203 
      return result.success
5204 
    if result.ex is not None:
5205 
      raise result.ex
5206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5207 
 
5481 phani.kuma 5208 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5209 
    """
5210 
    Parameters:
5211 
     - vendorId
5481 phani.kuma 5212 
     - onlyVendorNotPaid
5213 
     - billingDateFrom
5214 
     - billingDateTo
4875 varun.gupt 5215 
    """
5481 phani.kuma 5216 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5217 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5218 
 
5481 phani.kuma 5219 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5220 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5221 
    args = getBilledOrders_args()
4875 varun.gupt 5222 
    args.vendorId = vendorId
5481 phani.kuma 5223 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5224 
    args.billingDateFrom = billingDateFrom
5225 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5226 
    args.write(self._oprot)
5227 
    self._oprot.writeMessageEnd()
5228 
    self._oprot.trans.flush()
5229 
 
5481 phani.kuma 5230 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5232 
    if mtype == TMessageType.EXCEPTION:
5233 
      x = TApplicationException()
5234 
      x.read(self._iprot)
5235 
      self._iprot.readMessageEnd()
5236 
      raise x
5481 phani.kuma 5237 
    result = getBilledOrders_result()
4875 varun.gupt 5238 
    result.read(self._iprot)
5239 
    self._iprot.readMessageEnd()
5240 
    if result.success is not None:
5241 
      return result.success
5242 
    if result.ex is not None:
5243 
      raise result.ex
5481 phani.kuma 5244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5245 
 
5031 varun.gupt 5246 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5247 
    """
5248 
    Parameters:
5249 
     - startDate
5250 
     - endDate
5251 
    """
5252 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5253 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5254 
 
5031 varun.gupt 5255 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5256 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5257 
    args = getStatusDistributionOfOrders_args()
5258 
    args.startDate = startDate
5259 
    args.endDate = endDate
5260 
    args.write(self._oprot)
5261 
    self._oprot.writeMessageEnd()
5262 
    self._oprot.trans.flush()
5263 
 
5264 
  def recv_getStatusDistributionOfOrders(self, ):
5265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5266 
    if mtype == TMessageType.EXCEPTION:
5267 
      x = TApplicationException()
5268 
      x.read(self._iprot)
5269 
      self._iprot.readMessageEnd()
5270 
      raise x
5271 
    result = getStatusDistributionOfOrders_result()
5272 
    result.read(self._iprot)
5273 
    self._iprot.readMessageEnd()
5274 
    if result.success is not None:
5275 
      return result.success
5276 
    if result.ex is not None:
5277 
      raise result.ex
5278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5279 
 
5067 varun.gupt 5280 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5281 
    """
5282 
    Parameters:
5283 
     - status
5284 
     - startDatetime
5285 
     - endDatetime
5286 
    """
5287 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5288 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5289 
 
5067 varun.gupt 5290 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5291 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5292 
    args = getOrderIdsForStatus_args()
5293 
    args.status = status
5294 
    args.startDatetime = startDatetime
5295 
    args.endDatetime = endDatetime
5296 
    args.write(self._oprot)
5297 
    self._oprot.writeMessageEnd()
5298 
    self._oprot.trans.flush()
5299 
 
5300 
  def recv_getOrderIdsForStatus(self, ):
5301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5302 
    if mtype == TMessageType.EXCEPTION:
5303 
      x = TApplicationException()
5304 
      x.read(self._iprot)
5305 
      self._iprot.readMessageEnd()
5306 
      raise x
5307 
    result = getOrderIdsForStatus_result()
5308 
    result.read(self._iprot)
5309 
    self._iprot.readMessageEnd()
5310 
    if result.success is not None:
5311 
      return result.success
5312 
    if result.ex is not None:
5313 
      raise result.ex
5314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5315 
 
5348 anupam.sin 5316 
  def updateCODAgent(self, agent, orderId):
5317 
    """
5318 
    Updates the agent who handled the COD verification call
5319 
 
5320 
    Parameters:
5321 
     - agent
5322 
     - orderId
5323 
    """
5324 
    self.send_updateCODAgent(agent, orderId)
5325 
    self.recv_updateCODAgent()
5326 
 
5327 
  def send_updateCODAgent(self, agent, orderId):
5328 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5329 
    args = updateCODAgent_args()
5330 
    args.agent = agent
5331 
    args.orderId = orderId
5332 
    args.write(self._oprot)
5333 
    self._oprot.writeMessageEnd()
5334 
    self._oprot.trans.flush()
5335 
 
5336 
  def recv_updateCODAgent(self, ):
5337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5338 
    if mtype == TMessageType.EXCEPTION:
5339 
      x = TApplicationException()
5340 
      x.read(self._iprot)
5341 
      self._iprot.readMessageEnd()
5342 
      raise x
5343 
    result = updateCODAgent_result()
5344 
    result.read(self._iprot)
5345 
    self._iprot.readMessageEnd()
5346 
    if result.ex is not None:
5347 
      raise result.ex
5348 
    return
5349 
 
5099 varun.gupt 5350 
  def updateOrderAsPaidToVendor(self, orderId):
5351 
    """
5352 
    Parameters:
5353 
     - orderId
5354 
    """
5355 
    self.send_updateOrderAsPaidToVendor(orderId)
5356 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5357 
 
5099 varun.gupt 5358 
  def send_updateOrderAsPaidToVendor(self, orderId):
5359 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5360 
    args = updateOrderAsPaidToVendor_args()
5361 
    args.orderId = orderId
5362 
    args.write(self._oprot)
5363 
    self._oprot.writeMessageEnd()
5364 
    self._oprot.trans.flush()
5365 
 
5366 
  def recv_updateOrderAsPaidToVendor(self, ):
5367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5368 
    if mtype == TMessageType.EXCEPTION:
5369 
      x = TApplicationException()
5370 
      x.read(self._iprot)
5371 
      self._iprot.readMessageEnd()
5372 
      raise x
5373 
    result = updateOrderAsPaidToVendor_result()
5374 
    result.read(self._iprot)
5375 
    self._iprot.readMessageEnd()
5376 
    if result.ex is not None:
5377 
      raise result.ex
5378 
    return
5379 
 
5386 phani.kuma 5380 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5381 
    """
5382 
    Parameters:
5383 
     - orderId
5384 
    """
5385 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5386 
    self.recv_updateOrderOnlyAsPaidToVendor()
5387 
 
5388 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5389 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5390 
    args = updateOrderOnlyAsPaidToVendor_args()
5391 
    args.orderId = orderId
5392 
    args.write(self._oprot)
5393 
    self._oprot.writeMessageEnd()
5394 
    self._oprot.trans.flush()
5395 
 
5396 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5398 
    if mtype == TMessageType.EXCEPTION:
5399 
      x = TApplicationException()
5400 
      x.read(self._iprot)
5401 
      self._iprot.readMessageEnd()
5402 
      raise x
5403 
    result = updateOrderOnlyAsPaidToVendor_result()
5404 
    result.read(self._iprot)
5405 
    self._iprot.readMessageEnd()
5406 
    if result.ex is not None:
5407 
      raise result.ex
5408 
    return
5409 
 
5208 varun.gupt 5410 
  def getRefundedOrdersMarkedPaid(self, ):
5411 
    self.send_getRefundedOrdersMarkedPaid()
5412 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5413 
 
5208 varun.gupt 5414 
  def send_getRefundedOrdersMarkedPaid(self, ):
5415 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5416 
    args = getRefundedOrdersMarkedPaid_args()
5417 
    args.write(self._oprot)
5418 
    self._oprot.writeMessageEnd()
5419 
    self._oprot.trans.flush()
5420 
 
5421 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5423 
    if mtype == TMessageType.EXCEPTION:
5424 
      x = TApplicationException()
5425 
      x.read(self._iprot)
5426 
      self._iprot.readMessageEnd()
5427 
      raise x
5428 
    result = getRefundedOrdersMarkedPaid_result()
5429 
    result.read(self._iprot)
5430 
    self._iprot.readMessageEnd()
5431 
    if result.success is not None:
5432 
      return result.success
5433 
    if result.ex is not None:
5434 
      raise result.ex
5435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5436 
 
5447 anupam.sin 5437 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5438 
    """
5439 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5440 
 
5447 anupam.sin 5441 
 
5442 
    Parameters:
5443 
     - minOrderId
5444 
     - maxOrderId
5445 
    """
5446 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5447 
    return self.recv_getAllVerificationAgents()
5448 
 
5449 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5450 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5451 
    args = getAllVerificationAgents_args()
5452 
    args.minOrderId = minOrderId
5453 
    args.maxOrderId = maxOrderId
5454 
    args.write(self._oprot)
5455 
    self._oprot.writeMessageEnd()
5456 
    self._oprot.trans.flush()
5457 
 
5458 
  def recv_getAllVerificationAgents(self, ):
5459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5460 
    if mtype == TMessageType.EXCEPTION:
5461 
      x = TApplicationException()
5462 
      x.read(self._iprot)
5463 
      self._iprot.readMessageEnd()
5464 
      raise x
5465 
    result = getAllVerificationAgents_result()
5466 
    result.read(self._iprot)
5467 
    self._iprot.readMessageEnd()
5468 
    if result.success is not None:
5469 
      return result.success
5470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5471 
 
5527 anupam.sin 5472 
  def getAllAttributesForOrderId(self, orderId):
5473 
    """
5474 
    gets all attributes for a given orderId
5447 anupam.sin 5475 
 
5527 anupam.sin 5476 
    Parameters:
5477 
     - orderId
5478 
    """
5479 
    self.send_getAllAttributesForOrderId(orderId)
5480 
    return self.recv_getAllAttributesForOrderId()
5481 
 
5482 
  def send_getAllAttributesForOrderId(self, orderId):
5483 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5484 
    args = getAllAttributesForOrderId_args()
5485 
    args.orderId = orderId
5486 
    args.write(self._oprot)
5487 
    self._oprot.writeMessageEnd()
5488 
    self._oprot.trans.flush()
5489 
 
5490 
  def recv_getAllAttributesForOrderId(self, ):
5491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5492 
    if mtype == TMessageType.EXCEPTION:
5493 
      x = TApplicationException()
5494 
      x.read(self._iprot)
5495 
      self._iprot.readMessageEnd()
5496 
      raise x
5497 
    result = getAllAttributesForOrderId_result()
5498 
    result.read(self._iprot)
5499 
    self._iprot.readMessageEnd()
5500 
    if result.success is not None:
5501 
      return result.success
5502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5503 
 
5676 rajveer 5504 
  def setOrderAttributes(self, orderId, attributes):
5505 
    """
5506 
    sets attributes for an order
5507 
 
5508 
    Parameters:
5509 
     - orderId
5510 
     - attributes
5511 
    """
5512 
    self.send_setOrderAttributes(orderId, attributes)
5513 
    self.recv_setOrderAttributes()
5514 
 
5515 
  def send_setOrderAttributes(self, orderId, attributes):
5516 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5517 
    args = setOrderAttributes_args()
5518 
    args.orderId = orderId
5519 
    args.attributes = attributes
5520 
    args.write(self._oprot)
5521 
    self._oprot.writeMessageEnd()
5522 
    self._oprot.trans.flush()
5523 
 
5524 
  def recv_setOrderAttributes(self, ):
5525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5526 
    if mtype == TMessageType.EXCEPTION:
5527 
      x = TApplicationException()
5528 
      x.read(self._iprot)
5529 
      self._iprot.readMessageEnd()
5530 
      raise x
5531 
    result = setOrderAttributes_result()
5532 
    result.read(self._iprot)
5533 
    self._iprot.readMessageEnd()
5534 
    return
5535 
 
5527 anupam.sin 5536 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5537 
    """
5538 
    sets attributes for all orders in a transaction
5539 
 
5540 
    Parameters:
5541 
     - transactionId
5542 
     - attribute
5543 
    """
5544 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5545 
    self.recv_setOrderAttributeForTransaction()
5546 
 
5547 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5548 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5549 
    args = setOrderAttributeForTransaction_args()
5550 
    args.transactionId = transactionId
5551 
    args.attribute = attribute
5552 
    args.write(self._oprot)
5553 
    self._oprot.writeMessageEnd()
5554 
    self._oprot.trans.flush()
5555 
 
5556 
  def recv_setOrderAttributeForTransaction(self, ):
5557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5558 
    if mtype == TMessageType.EXCEPTION:
5559 
      x = TApplicationException()
5560 
      x.read(self._iprot)
5561 
      self._iprot.readMessageEnd()
5562 
      raise x
5563 
    result = setOrderAttributeForTransaction_result()
5564 
    result.read(self._iprot)
5565 
    self._iprot.readMessageEnd()
5566 
    return
5567 
 
5553 rajveer 5568 
  def getReceivePendingOrders(self, storeId):
5569 
    """
5570 
    Parameters:
5571 
     - storeId
5572 
    """
5573 
    self.send_getReceivePendingOrders(storeId)
5574 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5575 
 
5553 rajveer 5576 
  def send_getReceivePendingOrders(self, storeId):
5577 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5578 
    args = getReceivePendingOrders_args()
5579 
    args.storeId = storeId
5580 
    args.write(self._oprot)
5581 
    self._oprot.writeMessageEnd()
5582 
    self._oprot.trans.flush()
5583 
 
5584 
  def recv_getReceivePendingOrders(self, ):
5585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5586 
    if mtype == TMessageType.EXCEPTION:
5587 
      x = TApplicationException()
5588 
      x.read(self._iprot)
5589 
      self._iprot.readMessageEnd()
5590 
      raise x
5591 
    result = getReceivePendingOrders_result()
5592 
    result.read(self._iprot)
5593 
    self._iprot.readMessageEnd()
5594 
    if result.success is not None:
5595 
      return result.success
5596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5597 
 
5598 
  def getReceivedAtStoreOrders(self, storeId):
5599 
    """
5600 
    Parameters:
5601 
     - storeId
5602 
    """
5603 
    self.send_getReceivedAtStoreOrders(storeId)
5604 
    return self.recv_getReceivedAtStoreOrders()
5605 
 
5606 
  def send_getReceivedAtStoreOrders(self, storeId):
5607 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5608 
    args = getReceivedAtStoreOrders_args()
5609 
    args.storeId = storeId
5610 
    args.write(self._oprot)
5611 
    self._oprot.writeMessageEnd()
5612 
    self._oprot.trans.flush()
5613 
 
5614 
  def recv_getReceivedAtStoreOrders(self, ):
5615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5616 
    if mtype == TMessageType.EXCEPTION:
5617 
      x = TApplicationException()
5618 
      x.read(self._iprot)
5619 
      self._iprot.readMessageEnd()
5620 
      raise x
5621 
    result = getReceivedAtStoreOrders_result()
5622 
    result.read(self._iprot)
5623 
    self._iprot.readMessageEnd()
5624 
    if result.success is not None:
5625 
      return result.success
5626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5627 
 
5713 rajveer 5628 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5629 
    """
5630 
    Parameters:
5631 
     - storeId
5632 
     - fromDate
5633 
     - toDate
5634 
     - onlyCod
5635 
    """
5636 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5637 
    return self.recv_getOrdersCollectionAtStore()
5638 
 
5639 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5640 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5641 
    args = getOrdersCollectionAtStore_args()
5642 
    args.storeId = storeId
5643 
    args.fromDate = fromDate
5644 
    args.toDate = toDate
5645 
    args.onlyCod = onlyCod
5646 
    args.write(self._oprot)
5647 
    self._oprot.writeMessageEnd()
5648 
    self._oprot.trans.flush()
5649 
 
5650 
  def recv_getOrdersCollectionAtStore(self, ):
5651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5652 
    if mtype == TMessageType.EXCEPTION:
5653 
      x = TApplicationException()
5654 
      x.read(self._iprot)
5655 
      self._iprot.readMessageEnd()
5656 
      raise x
5657 
    result = getOrdersCollectionAtStore_result()
5658 
    result.read(self._iprot)
5659 
    self._iprot.readMessageEnd()
5660 
    if result.success is not None:
5661 
      return result.success
5662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5663 
 
5833 rajveer 5664 
  def getOrderAttributeValue(self, orderId, attributeName):
5665 
    """
5666 
    Parameters:
5667 
     - orderId
5668 
     - attributeName
5669 
    """
5670 
    self.send_getOrderAttributeValue(orderId, attributeName)
5671 
    return self.recv_getOrderAttributeValue()
5672 
 
5673 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5674 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5675 
    args = getOrderAttributeValue_args()
5676 
    args.orderId = orderId
5677 
    args.attributeName = attributeName
5678 
    args.write(self._oprot)
5679 
    self._oprot.writeMessageEnd()
5680 
    self._oprot.trans.flush()
5681 
 
5682 
  def recv_getOrderAttributeValue(self, ):
5683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5684 
    if mtype == TMessageType.EXCEPTION:
5685 
      x = TApplicationException()
5686 
      x.read(self._iprot)
5687 
      self._iprot.readMessageEnd()
5688 
      raise x
5689 
    result = getOrderAttributeValue_result()
5690 
    result.read(self._iprot)
5691 
    self._iprot.readMessageEnd()
5692 
    if result.success is not None:
5693 
      return result.success
5694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5695 
 
6019 rajveer 5696 
  def changeJacketNumber(self, orderId, jacketNumber):
5697 
    """
5698 
    Parameters:
5699 
     - orderId
5700 
     - jacketNumber
5701 
    """
5702 
    self.send_changeJacketNumber(orderId, jacketNumber)
5703 
    return self.recv_changeJacketNumber()
5704 
 
5705 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5706 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5707 
    args = changeJacketNumber_args()
5708 
    args.orderId = orderId
5709 
    args.jacketNumber = jacketNumber
5710 
    args.write(self._oprot)
5711 
    self._oprot.writeMessageEnd()
5712 
    self._oprot.trans.flush()
5713 
 
5714 
  def recv_changeJacketNumber(self, ):
5715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5716 
    if mtype == TMessageType.EXCEPTION:
5717 
      x = TApplicationException()
5718 
      x.read(self._iprot)
5719 
      self._iprot.readMessageEnd()
5720 
      raise x
5721 
    result = changeJacketNumber_result()
5722 
    result.read(self._iprot)
5723 
    self._iprot.readMessageEnd()
5724 
    if result.success is not None:
5725 
      return result.success
5726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5727 
 
5728 
  def markOrderAsRtoInTransit(self, orderId):
5729 
    """
5730 
    Parameters:
5731 
     - orderId
5732 
    """
5733 
    self.send_markOrderAsRtoInTransit(orderId)
5734 
    return self.recv_markOrderAsRtoInTransit()
5735 
 
5736 
  def send_markOrderAsRtoInTransit(self, orderId):
5737 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5738 
    args = markOrderAsRtoInTransit_args()
5739 
    args.orderId = orderId
5740 
    args.write(self._oprot)
5741 
    self._oprot.writeMessageEnd()
5742 
    self._oprot.trans.flush()
5743 
 
5744 
  def recv_markOrderAsRtoInTransit(self, ):
5745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5746 
    if mtype == TMessageType.EXCEPTION:
5747 
      x = TApplicationException()
5748 
      x.read(self._iprot)
5749 
      self._iprot.readMessageEnd()
5750 
      raise x
5751 
    result = markOrderAsRtoInTransit_result()
5752 
    result.read(self._iprot)
5753 
    self._iprot.readMessageEnd()
5754 
    if result.success is not None:
5755 
      return result.success
5756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5757 
 
5593 mandeep.dh 5758 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5759 
    """
5760 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5761 
    invoked while scanning IN of items.
5553 rajveer 5762 
 
5593 mandeep.dh 5763 
    Parameters:
5764 
     - itemId
5765 
     - quantity
5766 
     - fulfilmentWarehouseId
5767 
     - billingWarehouseId
5768 
    """
5769 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5770 
    self.recv_acceptOrderForItem()
5771 
 
5772 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5773 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5774 
    args = acceptOrderForItem_args()
5775 
    args.itemId = itemId
5776 
    args.quantity = quantity
5777 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5778 
    args.billingWarehouseId = billingWarehouseId
5779 
    args.write(self._oprot)
5780 
    self._oprot.writeMessageEnd()
5781 
    self._oprot.trans.flush()
5782 
 
5783 
  def recv_acceptOrderForItem(self, ):
5784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5785 
    if mtype == TMessageType.EXCEPTION:
5786 
      x = TApplicationException()
5787 
      x.read(self._iprot)
5788 
      self._iprot.readMessageEnd()
5789 
      raise x
5790 
    result = acceptOrderForItem_result()
5791 
    result.read(self._iprot)
5792 
    self._iprot.readMessageEnd()
5793 
    return
5794 
 
6000 mandeep.dh 5795 
  def createRechargeOrder(self, rechargeOrder):
5796 
    """
5797 
    Parameters:
5798 
     - rechargeOrder
5799 
    """
5800 
    self.send_createRechargeOrder(rechargeOrder)
5801 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5802 
 
6000 mandeep.dh 5803 
  def send_createRechargeOrder(self, rechargeOrder):
5804 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5805 
    args = createRechargeOrder_args()
5806 
    args.rechargeOrder = rechargeOrder
5807 
    args.write(self._oprot)
5808 
    self._oprot.writeMessageEnd()
5809 
    self._oprot.trans.flush()
5810 
 
5811 
  def recv_createRechargeOrder(self, ):
5812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5813 
    if mtype == TMessageType.EXCEPTION:
5814 
      x = TApplicationException()
5815 
      x.read(self._iprot)
5816 
      self._iprot.readMessageEnd()
5817 
      raise x
5818 
    result = createRechargeOrder_result()
5819 
    result.read(self._iprot)
5820 
    self._iprot.readMessageEnd()
5821 
    if result.success is not None:
5822 
      return result.success
5823 
    if result.ex is not None:
5824 
      raise result.ex
5825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5826 
 
6031 rajveer 5827 
  def getRechargeOrder(self, rechargeRrderId):
5828 
    """
5829 
    Parameters:
5830 
     - rechargeRrderId
5831 
    """
5832 
    self.send_getRechargeOrder(rechargeRrderId)
5833 
    return self.recv_getRechargeOrder()
5834 
 
5835 
  def send_getRechargeOrder(self, rechargeRrderId):
5836 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5837 
    args = getRechargeOrder_args()
5838 
    args.rechargeRrderId = rechargeRrderId
5839 
    args.write(self._oprot)
5840 
    self._oprot.writeMessageEnd()
5841 
    self._oprot.trans.flush()
5842 
 
5843 
  def recv_getRechargeOrder(self, ):
5844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5845 
    if mtype == TMessageType.EXCEPTION:
5846 
      x = TApplicationException()
5847 
      x.read(self._iprot)
5848 
      self._iprot.readMessageEnd()
5849 
      raise x
5850 
    result = getRechargeOrder_result()
5851 
    result.read(self._iprot)
5852 
    self._iprot.readMessageEnd()
5853 
    if result.success is not None:
5854 
      return result.success
5855 
    if result.ex is not None:
5856 
      raise result.ex
5857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5858 
 
5859 
  def getRechargeOrders(self, userId):
5860 
    """
5861 
    Parameters:
5862 
     - userId
5863 
    """
5864 
    self.send_getRechargeOrders(userId)
5865 
    return self.recv_getRechargeOrders()
5866 
 
5867 
  def send_getRechargeOrders(self, userId):
5868 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5869 
    args = getRechargeOrders_args()
5870 
    args.userId = userId
5871 
    args.write(self._oprot)
5872 
    self._oprot.writeMessageEnd()
5873 
    self._oprot.trans.flush()
5874 
 
5875 
  def recv_getRechargeOrders(self, ):
5876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5877 
    if mtype == TMessageType.EXCEPTION:
5878 
      x = TApplicationException()
5879 
      x.read(self._iprot)
5880 
      self._iprot.readMessageEnd()
5881 
      raise x
5882 
    result = getRechargeOrders_result()
5883 
    result.read(self._iprot)
5884 
    self._iprot.readMessageEnd()
5885 
    if result.success is not None:
5886 
      return result.success
5887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5888 
 
6000 mandeep.dh 5889 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5890 
    """
5891 
    Parameters:
5892 
     - rechargeOrderId
5893 
     - rechargeOrderStatus
5894 
    """
5895 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5896 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5897 
 
5898 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5899 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5900 
    args = updateRechargeOrderStatus_args()
5901 
    args.rechargeOrderId = rechargeOrderId
5902 
    args.rechargeOrderStatus = rechargeOrderStatus
5903 
    args.write(self._oprot)
5904 
    self._oprot.writeMessageEnd()
5905 
    self._oprot.trans.flush()
5906 
 
5907 
  def recv_updateRechargeOrderStatus(self, ):
5908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5909 
    if mtype == TMessageType.EXCEPTION:
5910 
      x = TApplicationException()
5911 
      x.read(self._iprot)
5912 
      self._iprot.readMessageEnd()
5913 
      raise x
5914 
    result = updateRechargeOrderStatus_result()
5915 
    result.read(self._iprot)
5916 
    self._iprot.readMessageEnd()
6031 rajveer 5917 
    if result.success is not None:
5918 
      return result.success
6000 mandeep.dh 5919 
    if result.ex is not None:
5920 
      raise result.ex
6031 rajveer 5921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5922 
 
6031 rajveer 5923 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5924 
    """
5925 
    Parameters:
6031 rajveer 5926 
     - rechargeOrderId
6000 mandeep.dh 5927 
    """
6031 rajveer 5928 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5929 
    return self.recv_activateRechargeTxn()
5930 
 
6031 rajveer 5931 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5932 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5933 
    args = activateRechargeTxn_args()
6031 rajveer 5934 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5935 
    args.write(self._oprot)
5936 
    self._oprot.writeMessageEnd()
5937 
    self._oprot.trans.flush()
5938 
 
5939 
  def recv_activateRechargeTxn(self, ):
5940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5941 
    if mtype == TMessageType.EXCEPTION:
5942 
      x = TApplicationException()
5943 
      x.read(self._iprot)
5944 
      self._iprot.readMessageEnd()
5945 
      raise x
5946 
    result = activateRechargeTxn_result()
5947 
    result.read(self._iprot)
5948 
    self._iprot.readMessageEnd()
5949 
    if result.success is not None:
5950 
      return result.success
5951 
    if result.ex is not None:
5952 
      raise result.ex
5953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5954 
 
6031 rajveer 5955 
  def getUserWallet(self, userId):
6000 mandeep.dh 5956 
    """
5957 
    Parameters:
6031 rajveer 5958 
     - userId
6000 mandeep.dh 5959 
    """
6031 rajveer 5960 
    self.send_getUserWallet(userId)
5961 
    return self.recv_getUserWallet()
6000 mandeep.dh 5962 
 
6031 rajveer 5963 
  def send_getUserWallet(self, userId):
5964 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
5965 
    args = getUserWallet_args()
5966 
    args.userId = userId
6000 mandeep.dh 5967 
    args.write(self._oprot)
5968 
    self._oprot.writeMessageEnd()
5969 
    self._oprot.trans.flush()
5970 
 
6031 rajveer 5971 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 5972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5973 
    if mtype == TMessageType.EXCEPTION:
5974 
      x = TApplicationException()
5975 
      x.read(self._iprot)
5976 
      self._iprot.readMessageEnd()
5977 
      raise x
6031 rajveer 5978 
    result = getUserWallet_result()
6000 mandeep.dh 5979 
    result.read(self._iprot)
5980 
    self._iprot.readMessageEnd()
5981 
    if result.success is not None:
5982 
      return result.success
6031 rajveer 5983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 5984 
 
6031 rajveer 5985 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 5986 
    """
5987 
    Parameters:
6031 rajveer 5988 
     - userId
6000 mandeep.dh 5989 
    """
6031 rajveer 5990 
    self.send_getUserWalletHistory(userId)
5991 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 5992 
 
6031 rajveer 5993 
  def send_getUserWalletHistory(self, userId):
5994 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
5995 
    args = getUserWalletHistory_args()
5996 
    args.userId = userId
6000 mandeep.dh 5997 
    args.write(self._oprot)
5998 
    self._oprot.writeMessageEnd()
5999 
    self._oprot.trans.flush()
6000 
 
6031 rajveer 6001 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6003 
    if mtype == TMessageType.EXCEPTION:
6004 
      x = TApplicationException()
6005 
      x.read(self._iprot)
6006 
      self._iprot.readMessageEnd()
6007 
      raise x
6031 rajveer 6008 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6009 
    result.read(self._iprot)
6010 
    self._iprot.readMessageEnd()
6011 
    if result.success is not None:
6012 
      return result.success
6031 rajveer 6013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6014 
 
6048 rajveer 6015 
  def getServiceProviders(self, rechargeType):
6016 
    """
6017 
    Parameters:
6018 
     - rechargeType
6019 
    """
6020 
    self.send_getServiceProviders(rechargeType)
6021 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6022 
 
6048 rajveer 6023 
  def send_getServiceProviders(self, rechargeType):
6024 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6025 
    args = getServiceProviders_args()
6026 
    args.rechargeType = rechargeType
6027 
    args.write(self._oprot)
6028 
    self._oprot.writeMessageEnd()
6029 
    self._oprot.trans.flush()
6030 
 
6031 
  def recv_getServiceProviders(self, ):
6032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6033 
    if mtype == TMessageType.EXCEPTION:
6034 
      x = TApplicationException()
6035 
      x.read(self._iprot)
6036 
      self._iprot.readMessageEnd()
6037 
      raise x
6038 
    result = getServiceProviders_result()
6039 
    result.read(self._iprot)
6040 
    self._iprot.readMessageEnd()
6041 
    if result.success is not None:
6042 
      return result.success
6043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6044 
 
6049 rajveer 6045 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6046 
    """
6047 
    Parameters:
6049 rajveer 6048 
     - rechargeType
6048 rajveer 6049 
     - deviceNumber
6050 
    """
6049 rajveer 6051 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6052 
    return self.recv_getServiceProviderForDevice()
6053 
 
6049 rajveer 6054 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6055 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6056 
    args = getServiceProviderForDevice_args()
6049 rajveer 6057 
    args.rechargeType = rechargeType
6048 rajveer 6058 
    args.deviceNumber = deviceNumber
6059 
    args.write(self._oprot)
6060 
    self._oprot.writeMessageEnd()
6061 
    self._oprot.trans.flush()
6062 
 
6063 
  def recv_getServiceProviderForDevice(self, ):
6064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6065 
    if mtype == TMessageType.EXCEPTION:
6066 
      x = TApplicationException()
6067 
      x.read(self._iprot)
6068 
      self._iprot.readMessageEnd()
6069 
      raise x
6070 
    result = getServiceProviderForDevice_result()
6071 
    result.read(self._iprot)
6072 
    self._iprot.readMessageEnd()
6073 
    if result.success is not None:
6074 
      return result.success
6075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6076 
 
6077 
 
3376 rajveer 6078 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6079 
  def __init__(self, handler):
3376 rajveer 6080 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6081 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6082 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6083 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6084 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6085 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6086 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6087 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6088 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6089 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6090 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6091 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6092 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6093 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6094 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6095 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6096 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6097 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6098 
    self._processMap["createOrder"] = Processor.process_createOrder
6099 
    self._processMap["getOrder"] = Processor.process_getOrder
6100 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6101 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6102 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6103 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6104 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6105 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6106 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6107 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6108 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6109 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6110 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6111 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6112 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6113 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6114 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6115 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6116 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6117 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6118 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6119 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6120 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6121 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6122 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6123 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6124 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6125 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6126 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6127 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6128 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6129 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6130 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6131 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6132 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6133 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6134 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6135 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6136 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6137 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6138 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6139 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6140 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6141 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6142 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6143 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6144 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6145 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6146 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6147 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6148 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6149 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6150 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6151 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6152 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6153 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6154 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6155 
    self._processMap["changeItem"] = Processor.process_changeItem
6156 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6157 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6158 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6159 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6160 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6161 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6162 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6163 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6164 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6165 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6166 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6167 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6168 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6169 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6170 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6171 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6172 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6173 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6174 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6175 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6176 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6177 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6178 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6179 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6180 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6181 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6182 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6183 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6184 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6185 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6186 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6187 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6188 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6189 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6190 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6191 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6192 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6193 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6194 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6195 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6196 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6197 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6198 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6199 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6200 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6201 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6202 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6203 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6204 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6205 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6206 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6207 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6208 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6209 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6210 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6211 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6212 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6213 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6214 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6048 rajveer 6215 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6216 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
94 ashish 6217 
 
6218 
  def process(self, iprot, oprot):
6219 
    (name, type, seqid) = iprot.readMessageBegin()
6220 
    if name not in self._processMap:
6221 
      iprot.skip(TType.STRUCT)
6222 
      iprot.readMessageEnd()
6223 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6224 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6225 
      x.write(oprot)
6226 
      oprot.writeMessageEnd()
6227 
      oprot.trans.flush()
6228 
      return
6229 
    else:
6230 
      self._processMap[name](self, seqid, iprot, oprot)
6231 
    return True
6232 
 
6233 
  def process_createTransaction(self, seqid, iprot, oprot):
6234 
    args = createTransaction_args()
6235 
    args.read(iprot)
6236 
    iprot.readMessageEnd()
6237 
    result = createTransaction_result()
6238 
    try:
132 ashish 6239 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6240 
    except TransactionServiceException, ex:
6241 
      result.ex = ex
6242 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6243 
    result.write(oprot)
6244 
    oprot.writeMessageEnd()
6245 
    oprot.trans.flush()
6246 
 
6247 
  def process_getTransaction(self, seqid, iprot, oprot):
6248 
    args = getTransaction_args()
6249 
    args.read(iprot)
6250 
    iprot.readMessageEnd()
6251 
    result = getTransaction_result()
6252 
    try:
6253 
      result.success = self._handler.getTransaction(args.id)
6254 
    except TransactionServiceException, ex:
6255 
      result.ex = ex
6256 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6257 
    result.write(oprot)
6258 
    oprot.writeMessageEnd()
6259 
    oprot.trans.flush()
6260 
 
6261 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6262 
    args = getTransactionsForCustomer_args()
6263 
    args.read(iprot)
6264 
    iprot.readMessageEnd()
6265 
    result = getTransactionsForCustomer_result()
6266 
    try:
6267 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6268 
    except TransactionServiceException, ex:
6269 
      result.ex = ex
6270 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6271 
    result.write(oprot)
6272 
    oprot.writeMessageEnd()
6273 
    oprot.trans.flush()
6274 
 
132 ashish 6275 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6276 
    args = getTransactionsForShoppingCartId_args()
6277 
    args.read(iprot)
6278 
    iprot.readMessageEnd()
6279 
    result = getTransactionsForShoppingCartId_result()
6280 
    try:
6281 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6282 
    except TransactionServiceException, ex:
6283 
      result.ex = ex
6284 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6285 
    result.write(oprot)
6286 
    oprot.writeMessageEnd()
6287 
    oprot.trans.flush()
6288 
 
94 ashish 6289 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6290 
    args = getTransactionStatus_args()
6291 
    args.read(iprot)
6292 
    iprot.readMessageEnd()
6293 
    result = getTransactionStatus_result()
6294 
    try:
6295 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6296 
    except TransactionServiceException, ex:
6297 
      result.ex = ex
6298 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6299 
    result.write(oprot)
6300 
    oprot.writeMessageEnd()
6301 
    oprot.trans.flush()
6302 
 
6303 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6304 
    args = changeTransactionStatus_args()
6305 
    args.read(iprot)
6306 
    iprot.readMessageEnd()
6307 
    result = changeTransactionStatus_result()
6308 
    try:
5527 anupam.sin 6309 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6310 
    except TransactionServiceException, ex:
6311 
      result.ex = ex
6312 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6313 
    result.write(oprot)
6314 
    oprot.writeMessageEnd()
6315 
    oprot.trans.flush()
6316 
 
1398 varun.gupt 6317 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6318 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6319 
    args.read(iprot)
6320 
    iprot.readMessageEnd()
1398 varun.gupt 6321 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6322 
    try:
1398 varun.gupt 6323 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6324 
    except TransactionServiceException, ex:
6325 
      result.ex = ex
1398 varun.gupt 6326 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6327 
    result.write(oprot)
6328 
    oprot.writeMessageEnd()
6329 
    oprot.trans.flush()
6330 
 
483 rajveer 6331 
  def process_getAllOrders(self, seqid, iprot, oprot):
6332 
    args = getAllOrders_args()
94 ashish 6333 
    args.read(iprot)
6334 
    iprot.readMessageEnd()
483 rajveer 6335 
    result = getAllOrders_result()
94 ashish 6336 
    try:
4801 anupam.sin 6337 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6338 
    except TransactionServiceException, ex:
6339 
      result.ex = ex
483 rajveer 6340 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6341 
    result.write(oprot)
6342 
    oprot.writeMessageEnd()
6343 
    oprot.trans.flush()
6344 
 
4133 chandransh 6345 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6346 
    args = getOrdersInBatch_args()
6347 
    args.read(iprot)
6348 
    iprot.readMessageEnd()
6349 
    result = getOrdersInBatch_result()
6350 
    try:
6351 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6352 
    except TransactionServiceException, ex:
6353 
      result.ex = ex
6354 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6355 
    result.write(oprot)
6356 
    oprot.writeMessageEnd()
6357 
    oprot.trans.flush()
6358 
 
6359 
  def process_getOrderCount(self, seqid, iprot, oprot):
6360 
    args = getOrderCount_args()
6361 
    args.read(iprot)
6362 
    iprot.readMessageEnd()
6363 
    result = getOrderCount_result()
6364 
    try:
6365 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6366 
    except TransactionServiceException, ex:
6367 
      result.ex = ex
6368 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6369 
    result.write(oprot)
6370 
    oprot.writeMessageEnd()
6371 
    oprot.trans.flush()
6372 
 
999 varun.gupt 6373 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6374 
    args = getOrdersByBillingDate_args()
6375 
    args.read(iprot)
6376 
    iprot.readMessageEnd()
6377 
    result = getOrdersByBillingDate_result()
6378 
    try:
6379 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6380 
    except TransactionServiceException, ex:
6381 
      result.ex = ex
6382 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6383 
    result.write(oprot)
6384 
    oprot.writeMessageEnd()
6385 
    oprot.trans.flush()
6386 
 
3427 chandransh 6387 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6388 
    args = getOrdersByShippingDate_args()
6389 
    args.read(iprot)
6390 
    iprot.readMessageEnd()
6391 
    result = getOrdersByShippingDate_result()
6392 
    try:
3451 chandransh 6393 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6394 
    except TransactionServiceException, ex:
6395 
      result.ex = ex
6396 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6397 
    result.write(oprot)
6398 
    oprot.writeMessageEnd()
6399 
    oprot.trans.flush()
6400 
 
1382 varun.gupt 6401 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6402 
    args = getReturnableOrdersForCustomer_args()
6403 
    args.read(iprot)
6404 
    iprot.readMessageEnd()
6405 
    result = getReturnableOrdersForCustomer_result()
6406 
    try:
6407 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6408 
    except TransactionServiceException, ex:
6409 
      result.ex = ex
6410 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6411 
    result.write(oprot)
6412 
    oprot.writeMessageEnd()
6413 
    oprot.trans.flush()
6414 
 
6415 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6416 
    args = getCancellableOrdersForCustomer_args()
6417 
    args.read(iprot)
6418 
    iprot.readMessageEnd()
6419 
    result = getCancellableOrdersForCustomer_result()
6420 
    try:
6421 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6422 
    except TransactionServiceException, ex:
6423 
      result.ex = ex
6424 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6425 
    result.write(oprot)
6426 
    oprot.writeMessageEnd()
6427 
    oprot.trans.flush()
6428 
 
483 rajveer 6429 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6430 
    args = changeOrderStatus_args()
94 ashish 6431 
    args.read(iprot)
6432 
    iprot.readMessageEnd()
483 rajveer 6433 
    result = changeOrderStatus_result()
94 ashish 6434 
    try:
483 rajveer 6435 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6436 
    except TransactionServiceException, ex:
6437 
      result.ex = ex
483 rajveer 6438 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6439 
    result.write(oprot)
6440 
    oprot.writeMessageEnd()
6441 
    oprot.trans.flush()
6442 
 
483 rajveer 6443 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6444 
    args = getOrdersForTransaction_args()
94 ashish 6445 
    args.read(iprot)
6446 
    iprot.readMessageEnd()
483 rajveer 6447 
    result = getOrdersForTransaction_result()
94 ashish 6448 
    try:
1528 ankur.sing 6449 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6450 
    except TransactionServiceException, ex:
6451 
      result.ex = ex
483 rajveer 6452 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6453 
    result.write(oprot)
6454 
    oprot.writeMessageEnd()
6455 
    oprot.trans.flush()
6456 
 
483 rajveer 6457 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6458 
    args = getOrdersForCustomer_args()
94 ashish 6459 
    args.read(iprot)
6460 
    iprot.readMessageEnd()
483 rajveer 6461 
    result = getOrdersForCustomer_result()
94 ashish 6462 
    try:
3014 chandransh 6463 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6464 
    except TransactionServiceException, ex:
6465 
      result.ex = ex
483 rajveer 6466 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6467 
    result.write(oprot)
6468 
    oprot.writeMessageEnd()
6469 
    oprot.trans.flush()
6470 
 
483 rajveer 6471 
  def process_createOrder(self, seqid, iprot, oprot):
6472 
    args = createOrder_args()
94 ashish 6473 
    args.read(iprot)
6474 
    iprot.readMessageEnd()
483 rajveer 6475 
    result = createOrder_result()
94 ashish 6476 
    try:
483 rajveer 6477 
      result.success = self._handler.createOrder(args.order)
94 ashish 6478 
    except TransactionServiceException, ex:
6479 
      result.ex = ex
483 rajveer 6480 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6481 
    result.write(oprot)
6482 
    oprot.writeMessageEnd()
6483 
    oprot.trans.flush()
6484 
 
483 rajveer 6485 
  def process_getOrder(self, seqid, iprot, oprot):
6486 
    args = getOrder_args()
94 ashish 6487 
    args.read(iprot)
6488 
    iprot.readMessageEnd()
483 rajveer 6489 
    result = getOrder_result()
94 ashish 6490 
    try:
483 rajveer 6491 
      result.success = self._handler.getOrder(args.id)
94 ashish 6492 
    except TransactionServiceException, ex:
6493 
      result.ex = ex
483 rajveer 6494 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6495 
    result.write(oprot)
6496 
    oprot.writeMessageEnd()
6497 
    oprot.trans.flush()
6498 
 
483 rajveer 6499 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6500 
    args = getLineItemsForOrder_args()
94 ashish 6501 
    args.read(iprot)
6502 
    iprot.readMessageEnd()
483 rajveer 6503 
    result = getLineItemsForOrder_result()
94 ashish 6504 
    try:
483 rajveer 6505 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6506 
    except TransactionServiceException, ex:
6507 
      result.ex = ex
483 rajveer 6508 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6509 
    result.write(oprot)
6510 
    oprot.writeMessageEnd()
6511 
    oprot.trans.flush()
6512 
 
4999 phani.kuma 6513 
  def process_getOrderList(self, seqid, iprot, oprot):
6514 
    args = getOrderList_args()
6515 
    args.read(iprot)
6516 
    iprot.readMessageEnd()
6517 
    result = getOrderList_result()
6518 
    result.success = self._handler.getOrderList(args.order_ids)
6519 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6520 
    result.write(oprot)
6521 
    oprot.writeMessageEnd()
6522 
    oprot.trans.flush()
6523 
 
5386 phani.kuma 6524 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6525 
    args = getOrderListForVendor_args()
6526 
    args.read(iprot)
6527 
    iprot.readMessageEnd()
6528 
    result = getOrderListForVendor_result()
6529 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6530 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6531 
    result.write(oprot)
6532 
    oprot.writeMessageEnd()
6533 
    oprot.trans.flush()
6534 
 
1528 ankur.sing 6535 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6536 
    args = getOrderForCustomer_args()
6537 
    args.read(iprot)
6538 
    iprot.readMessageEnd()
6539 
    result = getOrderForCustomer_result()
6540 
    try:
6541 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6542 
    except TransactionServiceException, ex:
6543 
      result.ex = ex
6544 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6545 
    result.write(oprot)
6546 
    oprot.writeMessageEnd()
6547 
    oprot.trans.flush()
6548 
 
3064 chandransh 6549 
  def process_getAlerts(self, seqid, iprot, oprot):
6550 
    args = getAlerts_args()
6551 
    args.read(iprot)
6552 
    iprot.readMessageEnd()
6553 
    result = getAlerts_result()
4444 rajveer 6554 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6555 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6556 
    result.write(oprot)
6557 
    oprot.writeMessageEnd()
6558 
    oprot.trans.flush()
6559 
 
4394 rajveer 6560 
  def process_addAlert(self, seqid, iprot, oprot):
6561 
    args = addAlert_args()
3064 chandransh 6562 
    args.read(iprot)
6563 
    iprot.readMessageEnd()
4394 rajveer 6564 
    result = addAlert_result()
4444 rajveer 6565 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6566 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6567 
    result.write(oprot)
6568 
    oprot.writeMessageEnd()
6569 
    oprot.trans.flush()
6570 
 
4444 rajveer 6571 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6572 
    args = markAlertsAsSeen_args()
6573 
    args.read(iprot)
6574 
    iprot.readMessageEnd()
6575 
    result = markAlertsAsSeen_result()
6576 
    self._handler.markAlertsAsSeen(args.warehouseId)
6577 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6578 
    result.write(oprot)
6579 
    oprot.writeMessageEnd()
6580 
    oprot.trans.flush()
6581 
 
3064 chandransh 6582 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6583 
    args = getValidOrderCount_args()
6584 
    args.read(iprot)
6585 
    iprot.readMessageEnd()
6586 
    result = getValidOrderCount_result()
6587 
    result.success = self._handler.getValidOrderCount()
6588 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6589 
    result.write(oprot)
6590 
    oprot.writeMessageEnd()
6591 
    oprot.trans.flush()
6592 
 
6593 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6594 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6595 
    args.read(iprot)
6596 
    iprot.readMessageEnd()
6597 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6598 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6599 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6600 
    result.write(oprot)
6601 
    oprot.writeMessageEnd()
6602 
    oprot.trans.flush()
6603 
 
6604 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6605 
    args = getValidOrdersAmountRange_args()
6606 
    args.read(iprot)
6607 
    iprot.readMessageEnd()
6608 
    result = getValidOrdersAmountRange_result()
6609 
    result.success = self._handler.getValidOrdersAmountRange()
6610 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6611 
    result.write(oprot)
6612 
    oprot.writeMessageEnd()
6613 
    oprot.trans.flush()
6614 
 
6615 
  def process_getValidOrders(self, seqid, iprot, oprot):
6616 
    args = getValidOrders_args()
6617 
    args.read(iprot)
6618 
    iprot.readMessageEnd()
6619 
    result = getValidOrders_result()
5874 rajveer 6620 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6621 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6622 
    result.write(oprot)
6623 
    oprot.writeMessageEnd()
6624 
    oprot.trans.flush()
6625 
 
1220 chandransh 6626 
  def process_batchOrders(self, seqid, iprot, oprot):
6627 
    args = batchOrders_args()
6628 
    args.read(iprot)
6629 
    iprot.readMessageEnd()
6630 
    result = batchOrders_result()
6631 
    try:
6632 
      result.success = self._handler.batchOrders(args.warehouseId)
6633 
    except TransactionServiceException, ex:
6634 
      result.ex = ex
6635 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6636 
    result.write(oprot)
6637 
    oprot.writeMessageEnd()
6638 
    oprot.trans.flush()
6639 
 
1208 chandransh 6640 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6641 
    args = markOrderAsOutOfStock_args()
6642 
    args.read(iprot)
6643 
    iprot.readMessageEnd()
6644 
    result = markOrderAsOutOfStock_result()
6645 
    try:
6646 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6647 
    except TransactionServiceException, ex:
6648 
      result.ex = ex
6649 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6650 
    result.write(oprot)
6651 
    oprot.writeMessageEnd()
6652 
    oprot.trans.flush()
6653 
 
3064 chandransh 6654 
  def process_verifyOrder(self, seqid, iprot, oprot):
6655 
    args = verifyOrder_args()
759 chandransh 6656 
    args.read(iprot)
6657 
    iprot.readMessageEnd()
3064 chandransh 6658 
    result = verifyOrder_result()
759 chandransh 6659 
    try:
3064 chandransh 6660 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6661 
    except TransactionServiceException, ex:
6662 
      result.ex = ex
3064 chandransh 6663 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6664 
    result.write(oprot)
6665 
    oprot.writeMessageEnd()
6666 
    oprot.trans.flush()
6667 
 
3064 chandransh 6668 
  def process_acceptOrder(self, seqid, iprot, oprot):
6669 
    args = acceptOrder_args()
1113 chandransh 6670 
    args.read(iprot)
6671 
    iprot.readMessageEnd()
3064 chandransh 6672 
    result = acceptOrder_result()
1113 chandransh 6673 
    try:
3064 chandransh 6674 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6675 
    except TransactionServiceException, ex:
6676 
      result.ex = ex
3064 chandransh 6677 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6678 
    result.write(oprot)
6679 
    oprot.writeMessageEnd()
6680 
    oprot.trans.flush()
6681 
 
3064 chandransh 6682 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6683 
    args = addBillingDetails_args()
1135 chandransh 6684 
    args.read(iprot)
6685 
    iprot.readMessageEnd()
3064 chandransh 6686 
    result = addBillingDetails_result()
1135 chandransh 6687 
    try:
5110 mandeep.dh 6688 
      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 6689 
    except TransactionServiceException, ex:
6690 
      result.ex = ex
3064 chandransh 6691 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6692 
    result.write(oprot)
6693 
    oprot.writeMessageEnd()
6694 
    oprot.trans.flush()
6695 
 
4579 rajveer 6696 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6697 
    args = addInvoiceNumber_args()
6698 
    args.read(iprot)
6699 
    iprot.readMessageEnd()
6700 
    result = addInvoiceNumber_result()
6701 
    try:
4763 rajveer 6702 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6703 
    except TransactionServiceException, ex:
6704 
      result.ex = ex
6705 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6706 
    result.write(oprot)
6707 
    oprot.writeMessageEnd()
6708 
    oprot.trans.flush()
6709 
 
4410 rajveer 6710 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6711 
    args = markOrdersAsShippedFromWarehouse_args()
6712 
    args.read(iprot)
6713 
    iprot.readMessageEnd()
6714 
    result = markOrdersAsShippedFromWarehouse_result()
6715 
    try:
4789 rajveer 6716 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6717 
    except TransactionServiceException, ex:
6718 
      result.ex = ex
6719 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6720 
    result.write(oprot)
6721 
    oprot.writeMessageEnd()
6722 
    oprot.trans.flush()
6723 
 
5676 rajveer 6724 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6725 
    args = markOrdersAsReturnedFromStore_args()
6726 
    args.read(iprot)
6727 
    iprot.readMessageEnd()
6728 
    result = markOrdersAsReturnedFromStore_result()
6729 
    try:
5713 rajveer 6730 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6731 
    except TransactionServiceException, ex:
6732 
      result.ex = ex
6733 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6734 
    result.write(oprot)
6735 
    oprot.writeMessageEnd()
6736 
    oprot.trans.flush()
6737 
 
3064 chandransh 6738 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6739 
    args = markOrdersAsPickedUp_args()
304 ashish 6740 
    args.read(iprot)
6741 
    iprot.readMessageEnd()
3064 chandransh 6742 
    result = markOrdersAsPickedUp_result()
6743 
    try:
4910 phani.kuma 6744 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6745 
    except TransactionServiceException, ex:
6746 
      result.ex = ex
6747 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6748 
    result.write(oprot)
6749 
    oprot.writeMessageEnd()
6750 
    oprot.trans.flush()
94 ashish 6751 
 
4910 phani.kuma 6752 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6753 
    args = getOrdersNotPickedUp_args()
6754 
    args.read(iprot)
6755 
    iprot.readMessageEnd()
6756 
    result = getOrdersNotPickedUp_result()
6757 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6758 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6759 
    result.write(oprot)
6760 
    oprot.writeMessageEnd()
6761 
    oprot.trans.flush()
6762 
 
3064 chandransh 6763 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6764 
    args = markOrdersAsDelivered_args()
304 ashish 6765 
    args.read(iprot)
6766 
    iprot.readMessageEnd()
3064 chandransh 6767 
    result = markOrdersAsDelivered_result()
6768 
    try:
6769 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6770 
    except TransactionServiceException, ex:
6771 
      result.ex = ex
6772 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6773 
    result.write(oprot)
6774 
    oprot.writeMessageEnd()
6775 
    oprot.trans.flush()
6776 
 
4910 phani.kuma 6777 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6778 
    args = markAsRTOrders_args()
1596 ankur.sing 6779 
    args.read(iprot)
6780 
    iprot.readMessageEnd()
4910 phani.kuma 6781 
    result = markAsRTOrders_result()
3064 chandransh 6782 
    try:
4910 phani.kuma 6783 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6784 
    except TransactionServiceException, ex:
6785 
      result.ex = ex
4910 phani.kuma 6786 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6787 
    result.write(oprot)
6788 
    oprot.writeMessageEnd()
6789 
    oprot.trans.flush()
304 ashish 6790 
 
4910 phani.kuma 6791 
  def process_getRTOrders(self, seqid, iprot, oprot):
6792 
    args = getRTOrders_args()
6793 
    args.read(iprot)
6794 
    iprot.readMessageEnd()
6795 
    result = getRTOrders_result()
6796 
    result.success = self._handler.getRTOrders(args.providerId)
6797 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6798 
    result.write(oprot)
6799 
    oprot.writeMessageEnd()
6800 
    oprot.trans.flush()
6801 
 
3064 chandransh 6802 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6803 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6804 
    args.read(iprot)
6805 
    iprot.readMessageEnd()
3064 chandransh 6806 
    result = updateNonDeliveryReason_result()
6807 
    try:
4910 phani.kuma 6808 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6809 
    except TransactionServiceException, ex:
6810 
      result.ex = ex
6811 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6812 
    result.write(oprot)
6813 
    oprot.writeMessageEnd()
6814 
    oprot.trans.flush()
1596 ankur.sing 6815 
 
4910 phani.kuma 6816 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6817 
    args = getNonDeliveredOrdersbyCourier_args()
6818 
    args.read(iprot)
6819 
    iprot.readMessageEnd()
6820 
    result = getNonDeliveredOrdersbyCourier_result()
6821 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6822 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6823 
    result.write(oprot)
6824 
    oprot.writeMessageEnd()
6825 
    oprot.trans.flush()
6826 
 
6827 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6828 
    args = markOrdersAsLocalConnected_args()
6829 
    args.read(iprot)
6830 
    iprot.readMessageEnd()
6831 
    result = markOrdersAsLocalConnected_result()
6832 
    try:
6833 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6834 
    except TransactionServiceException, ex:
6835 
      result.ex = ex
6836 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6837 
    result.write(oprot)
6838 
    oprot.writeMessageEnd()
6839 
    oprot.trans.flush()
6840 
 
6841 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6842 
    args = getOrdersNotLocalConnected_args()
6843 
    args.read(iprot)
6844 
    iprot.readMessageEnd()
6845 
    result = getOrdersNotLocalConnected_result()
6846 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6847 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6848 
    result.write(oprot)
6849 
    oprot.writeMessageEnd()
6850 
    oprot.trans.flush()
6851 
 
6852 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6853 
    args = markOrdersAsDestinationCityReached_args()
6854 
    args.read(iprot)
6855 
    iprot.readMessageEnd()
6856 
    result = markOrdersAsDestinationCityReached_result()
6857 
    try:
6858 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6859 
    except TransactionServiceException, ex:
6860 
      result.ex = ex
6861 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6862 
    result.write(oprot)
6863 
    oprot.writeMessageEnd()
6864 
    oprot.trans.flush()
6865 
 
6866 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6867 
    args = markOrdersAsFirstDeliveryAttempted_args()
6868 
    args.read(iprot)
6869 
    iprot.readMessageEnd()
6870 
    result = markOrdersAsFirstDeliveryAttempted_result()
6871 
    try:
6872 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6873 
    except TransactionServiceException, ex:
6874 
      result.ex = ex
6875 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6876 
    result.write(oprot)
6877 
    oprot.writeMessageEnd()
6878 
    oprot.trans.flush()
6879 
 
3064 chandransh 6880 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6881 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6882 
    args.read(iprot)
6883 
    iprot.readMessageEnd()
3064 chandransh 6884 
    result = getUndeliveredOrders_result()
6885 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6886 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6887 
    result.write(oprot)
6888 
    oprot.writeMessageEnd()
6889 
    oprot.trans.flush()
6890 
 
4783 phani.kuma 6891 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6892 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6893 
    args.read(iprot)
6894 
    iprot.readMessageEnd()
6895 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6896 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6897 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6898 
    result.write(oprot)
6899 
    oprot.writeMessageEnd()
6900 
    oprot.trans.flush()
6901 
 
2536 chandransh 6902 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6903 
    args = toggleDOAFlag_args()
6904 
    args.read(iprot)
6905 
    iprot.readMessageEnd()
6906 
    result = toggleDOAFlag_result()
6907 
    try:
6908 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6909 
    except TransactionServiceException, ex:
6910 
      result.ex = ex
6911 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6912 
    result.write(oprot)
6913 
    oprot.writeMessageEnd()
6914 
    oprot.trans.flush()
1886 ankur.sing 6915 
 
4712 rajveer 6916 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6917 
    args = markOrderAsDelivered_args()
6918 
    args.read(iprot)
6919 
    iprot.readMessageEnd()
6920 
    result = markOrderAsDelivered_result()
6921 
    try:
6922 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6923 
    except TransactionServiceException, ex:
6924 
      result.ex = ex
6925 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6926 
    result.write(oprot)
6927 
    oprot.writeMessageEnd()
6928 
    oprot.trans.flush()
6929 
 
5553 rajveer 6930 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6931 
    args = markOrderAsReceivedAtStore_args()
6932 
    args.read(iprot)
6933 
    iprot.readMessageEnd()
6934 
    result = markOrderAsReceivedAtStore_result()
6935 
    try:
6936 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6937 
    except TransactionServiceException, ex:
6938 
      result.ex = ex
6939 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6940 
    result.write(oprot)
6941 
    oprot.writeMessageEnd()
6942 
    oprot.trans.flush()
6943 
 
4454 rajveer 6944 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6945 
    args = markOrderDoaRequestReceived_args()
6946 
    args.read(iprot)
6947 
    iprot.readMessageEnd()
6948 
    result = markOrderDoaRequestReceived_result()
6949 
    try:
6950 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6951 
    except TransactionServiceException, ex:
6952 
      result.ex = ex
6953 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6954 
    result.write(oprot)
6955 
    oprot.writeMessageEnd()
6956 
    oprot.trans.flush()
6957 
 
6958 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6959 
    args = markOrderDoaRequestAuthorized_args()
6960 
    args.read(iprot)
6961 
    iprot.readMessageEnd()
6962 
    result = markOrderDoaRequestAuthorized_result()
6963 
    try:
6964 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6965 
    except TransactionServiceException, ex:
6966 
      result.ex = ex
6967 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6968 
    result.write(oprot)
6969 
    oprot.writeMessageEnd()
6970 
    oprot.trans.flush()
6971 
 
4488 rajveer 6972 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6973 
    args = markOrderReturnRequestReceived_args()
6974 
    args.read(iprot)
6975 
    iprot.readMessageEnd()
6976 
    result = markOrderReturnRequestReceived_result()
6977 
    try:
6978 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6979 
    except TransactionServiceException, ex:
6980 
      result.ex = ex
6981 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6982 
    result.write(oprot)
6983 
    oprot.writeMessageEnd()
6984 
    oprot.trans.flush()
6985 
 
6986 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6987 
    args = markOrderReturnRequestAuthorized_args()
6988 
    args.read(iprot)
6989 
    iprot.readMessageEnd()
6990 
    result = markOrderReturnRequestAuthorized_result()
6991 
    try:
6992 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6993 
    except TransactionServiceException, ex:
6994 
      result.ex = ex
6995 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6996 
    result.write(oprot)
6997 
    oprot.writeMessageEnd()
6998 
    oprot.trans.flush()
6999 
 
2536 chandransh 7000 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7001 
    args = requestPickupNumber_args()
7002 
    args.read(iprot)
7003 
    iprot.readMessageEnd()
7004 
    result = requestPickupNumber_result()
7005 
    try:
4579 rajveer 7006 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7007 
    except TransactionServiceException, ex:
7008 
      result.ex = ex
7009 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7010 
    result.write(oprot)
7011 
    oprot.writeMessageEnd()
7012 
    oprot.trans.flush()
7013 
 
7014 
  def process_authorizePickup(self, seqid, iprot, oprot):
7015 
    args = authorizePickup_args()
7016 
    args.read(iprot)
7017 
    iprot.readMessageEnd()
7018 
    result = authorizePickup_result()
7019 
    try:
4602 rajveer 7020 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7021 
    except TransactionServiceException, ex:
7022 
      result.ex = ex
7023 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7024 
    result.write(oprot)
7025 
    oprot.writeMessageEnd()
7026 
    oprot.trans.flush()
7027 
 
2764 chandransh 7028 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7029 
    args = markDoasAsPickedUp_args()
7030 
    args.read(iprot)
7031 
    iprot.readMessageEnd()
7032 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7033 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7034 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7035 
    result.write(oprot)
7036 
    oprot.writeMessageEnd()
7037 
    oprot.trans.flush()
7038 
 
4910 phani.kuma 7039 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7040 
    args = getDoasNotPickedUp_args()
7041 
    args.read(iprot)
7042 
    iprot.readMessageEnd()
7043 
    result = getDoasNotPickedUp_result()
7044 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7045 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7046 
    result.write(oprot)
7047 
    oprot.writeMessageEnd()
7048 
    oprot.trans.flush()
7049 
 
4741 phani.kuma 7050 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7051 
    args = markReturnOrdersAsPickedUp_args()
7052 
    args.read(iprot)
7053 
    iprot.readMessageEnd()
7054 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7055 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7056 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7057 
    result.write(oprot)
7058 
    oprot.writeMessageEnd()
7059 
    oprot.trans.flush()
7060 
 
4910 phani.kuma 7061 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7062 
    args = getReturnOrdersNotPickedUp_args()
7063 
    args.read(iprot)
7064 
    iprot.readMessageEnd()
7065 
    result = getReturnOrdersNotPickedUp_result()
7066 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7067 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7068 
    result.write(oprot)
7069 
    oprot.writeMessageEnd()
7070 
    oprot.trans.flush()
7071 
 
2616 chandransh 7072 
  def process_receiveReturn(self, seqid, iprot, oprot):
7073 
    args = receiveReturn_args()
2591 chandransh 7074 
    args.read(iprot)
7075 
    iprot.readMessageEnd()
2616 chandransh 7076 
    result = receiveReturn_result()
2591 chandransh 7077 
    try:
4479 rajveer 7078 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7079 
    except TransactionServiceException, ex:
7080 
      result.ex = ex
2616 chandransh 7081 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7082 
    result.write(oprot)
7083 
    oprot.writeMessageEnd()
7084 
    oprot.trans.flush()
2536 chandransh 7085 
 
2591 chandransh 7086 
  def process_validateDoa(self, seqid, iprot, oprot):
7087 
    args = validateDoa_args()
7088 
    args.read(iprot)
7089 
    iprot.readMessageEnd()
7090 
    result = validateDoa_result()
7091 
    try:
7092 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7093 
    except TransactionServiceException, ex:
7094 
      result.ex = ex
7095 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7096 
    result.write(oprot)
7097 
    oprot.writeMessageEnd()
7098 
    oprot.trans.flush()
7099 
 
4495 rajveer 7100 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7101 
    args = validateReturnProduct_args()
7102 
    args.read(iprot)
7103 
    iprot.readMessageEnd()
7104 
    result = validateReturnProduct_result()
7105 
    try:
7106 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7107 
    except TransactionServiceException, ex:
7108 
      result.ex = ex
7109 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7110 
    result.write(oprot)
7111 
    oprot.writeMessageEnd()
7112 
    oprot.trans.flush()
7113 
 
2616 chandransh 7114 
  def process_reshipOrder(self, seqid, iprot, oprot):
7115 
    args = reshipOrder_args()
7116 
    args.read(iprot)
7117 
    iprot.readMessageEnd()
7118 
    result = reshipOrder_result()
7119 
    try:
7120 
      result.success = self._handler.reshipOrder(args.orderId)
7121 
    except TransactionServiceException, ex:
7122 
      result.ex = ex
7123 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7124 
    result.write(oprot)
7125 
    oprot.writeMessageEnd()
7126 
    oprot.trans.flush()
2591 chandransh 7127 
 
2616 chandransh 7128 
  def process_refundOrder(self, seqid, iprot, oprot):
7129 
    args = refundOrder_args()
7130 
    args.read(iprot)
7131 
    iprot.readMessageEnd()
7132 
    result = refundOrder_result()
7133 
    try:
3226 chandransh 7134 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7135 
    except TransactionServiceException, ex:
7136 
      result.ex = ex
7137 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7138 
    result.write(oprot)
7139 
    oprot.writeMessageEnd()
7140 
    oprot.trans.flush()
7141 
 
2690 chandransh 7142 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7143 
    args = getReturnOrders_args()
7144 
    args.read(iprot)
7145 
    iprot.readMessageEnd()
7146 
    result = getReturnOrders_result()
7147 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7148 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7149 
    result.write(oprot)
7150 
    oprot.writeMessageEnd()
7151 
    oprot.trans.flush()
2616 chandransh 7152 
 
5481 phani.kuma 7153 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7154 
    args = getAllReturnOrders_args()
7155 
    args.read(iprot)
7156 
    iprot.readMessageEnd()
7157 
    result = getAllReturnOrders_result()
7158 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7159 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7160 
    result.write(oprot)
7161 
    oprot.writeMessageEnd()
7162 
    oprot.trans.flush()
7163 
 
2700 chandransh 7164 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7165 
    args = getReturnOrder_args()
7166 
    args.read(iprot)
7167 
    iprot.readMessageEnd()
7168 
    result = getReturnOrder_result()
7169 
    try:
7170 
      result.success = self._handler.getReturnOrder(args.id)
7171 
    except TransactionServiceException, ex:
7172 
      result.ex = ex
7173 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7174 
    result.write(oprot)
7175 
    oprot.writeMessageEnd()
7176 
    oprot.trans.flush()
7177 
 
2690 chandransh 7178 
  def process_processReturn(self, seqid, iprot, oprot):
7179 
    args = processReturn_args()
7180 
    args.read(iprot)
7181 
    iprot.readMessageEnd()
7182 
    result = processReturn_result()
7183 
    try:
7184 
      self._handler.processReturn(args.returnOrderId)
7185 
    except TransactionServiceException, ex:
7186 
      result.ex = ex
7187 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7188 
    result.write(oprot)
7189 
    oprot.writeMessageEnd()
7190 
    oprot.trans.flush()
7191 
 
3451 chandransh 7192 
  def process_updateWeight(self, seqid, iprot, oprot):
7193 
    args = updateWeight_args()
7194 
    args.read(iprot)
7195 
    iprot.readMessageEnd()
7196 
    result = updateWeight_result()
7197 
    try:
7198 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7199 
    except TransactionServiceException, ex:
7200 
      result.ex = ex
7201 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7202 
    result.write(oprot)
7203 
    oprot.writeMessageEnd()
7204 
    oprot.trans.flush()
2819 chandransh 7205 
 
3469 chandransh 7206 
  def process_changeItem(self, seqid, iprot, oprot):
7207 
    args = changeItem_args()
7208 
    args.read(iprot)
7209 
    iprot.readMessageEnd()
7210 
    result = changeItem_result()
7211 
    try:
7212 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7213 
    except TransactionServiceException, ex:
7214 
      result.ex = ex
7215 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7216 
    result.write(oprot)
7217 
    oprot.writeMessageEnd()
7218 
    oprot.trans.flush()
3451 chandransh 7219 
 
3469 chandransh 7220 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7221 
    args = shiftToWarehouse_args()
7222 
    args.read(iprot)
7223 
    iprot.readMessageEnd()
7224 
    result = shiftToWarehouse_result()
7225 
    try:
7226 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7227 
    except TransactionServiceException, ex:
7228 
      result.ex = ex
7229 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7230 
    result.write(oprot)
7231 
    oprot.writeMessageEnd()
7232 
    oprot.trans.flush()
7233 
 
3553 chandransh 7234 
  def process_addDelayReason(self, seqid, iprot, oprot):
7235 
    args = addDelayReason_args()
7236 
    args.read(iprot)
7237 
    iprot.readMessageEnd()
7238 
    result = addDelayReason_result()
7239 
    try:
4647 rajveer 7240 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7241 
    except TransactionServiceException, ex:
7242 
      result.ex = ex
7243 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7244 
    result.write(oprot)
7245 
    oprot.writeMessageEnd()
7246 
    oprot.trans.flush()
3469 chandransh 7247 
 
3956 chandransh 7248 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7249 
    args = reconcileCodCollection_args()
7250 
    args.read(iprot)
7251 
    iprot.readMessageEnd()
7252 
    result = reconcileCodCollection_result()
7253 
    try:
7254 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7255 
    except TransactionServiceException, ex:
7256 
      result.ex = ex
7257 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7258 
    result.write(oprot)
7259 
    oprot.writeMessageEnd()
7260 
    oprot.trans.flush()
3553 chandransh 7261 
 
4008 mandeep.dh 7262 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7263 
    args = getTransactionsRequiringExtraProcessing_args()
7264 
    args.read(iprot)
7265 
    iprot.readMessageEnd()
7266 
    result = getTransactionsRequiringExtraProcessing_result()
7267 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7268 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7269 
    result.write(oprot)
7270 
    oprot.writeMessageEnd()
7271 
    oprot.trans.flush()
3956 chandransh 7272 
 
4008 mandeep.dh 7273 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7274 
    args = markTransactionAsProcessed_args()
7275 
    args.read(iprot)
7276 
    iprot.readMessageEnd()
7277 
    result = markTransactionAsProcessed_result()
7278 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7279 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7280 
    result.write(oprot)
7281 
    oprot.writeMessageEnd()
7282 
    oprot.trans.flush()
7283 
 
4018 chandransh 7284 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7285 
    args = getItemWiseRiskyOrdersCount_args()
7286 
    args.read(iprot)
7287 
    iprot.readMessageEnd()
7288 
    result = getItemWiseRiskyOrdersCount_result()
7289 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7290 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7291 
    result.write(oprot)
7292 
    oprot.writeMessageEnd()
7293 
    oprot.trans.flush()
4008 mandeep.dh 7294 
 
4295 varun.gupt 7295 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7296 
    args = getOrdersForItemIds_args()
7297 
    args.read(iprot)
7298 
    iprot.readMessageEnd()
7299 
    result = getOrdersForItemIds_result()
7300 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7301 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7302 
    result.write(oprot)
7303 
    oprot.writeMessageEnd()
7304 
    oprot.trans.flush()
7305 
 
4247 rajveer 7306 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7307 
    args = markOrderCancellationRequestReceived_args()
7308 
    args.read(iprot)
7309 
    iprot.readMessageEnd()
7310 
    result = markOrderCancellationRequestReceived_result()
7311 
    try:
7312 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7313 
    except TransactionServiceException, ex:
7314 
      result.ex = ex
7315 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7316 
    result.write(oprot)
7317 
    oprot.writeMessageEnd()
7318 
    oprot.trans.flush()
4018 chandransh 7319 
 
4247 rajveer 7320 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7321 
    args = markOrderCancellationRequestConfirmed_args()
7322 
    args.read(iprot)
7323 
    iprot.readMessageEnd()
7324 
    result = markOrderCancellationRequestConfirmed_result()
7325 
    try:
7326 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7327 
    except TransactionServiceException, ex:
7328 
      result.ex = ex
7329 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7330 
    result.write(oprot)
7331 
    oprot.writeMessageEnd()
7332 
    oprot.trans.flush()
7333 
 
7334 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7335 
    args = markOrderCancellationRequestDenied_args()
7336 
    args.read(iprot)
7337 
    iprot.readMessageEnd()
7338 
    result = markOrderCancellationRequestDenied_result()
7339 
    try:
7340 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7341 
    except TransactionServiceException, ex:
7342 
      result.ex = ex
7343 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7344 
    result.write(oprot)
7345 
    oprot.writeMessageEnd()
7346 
    oprot.trans.flush()
7347 
 
4258 rajveer 7348 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7349 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7350 
    args.read(iprot)
7351 
    iprot.readMessageEnd()
4258 rajveer 7352 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7353 
    try:
4258 rajveer 7354 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7355 
    except TransactionServiceException, ex:
7356 
      result.ex = ex
4258 rajveer 7357 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7358 
    result.write(oprot)
7359 
    oprot.writeMessageEnd()
7360 
    oprot.trans.flush()
7361 
 
4259 anupam.sin 7362 
  def process_refundTransaction(self, seqid, iprot, oprot):
7363 
    args = refundTransaction_args()
7364 
    args.read(iprot)
7365 
    iprot.readMessageEnd()
7366 
    result = refundTransaction_result()
7367 
    try:
7368 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7369 
    except TransactionServiceException, ex:
7370 
      result.ex = ex
7371 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7372 
    result.write(oprot)
7373 
    oprot.writeMessageEnd()
7374 
    oprot.trans.flush()
4247 rajveer 7375 
 
4324 mandeep.dh 7376 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7377 
    args = updateShipmentAddress_args()
7378 
    args.read(iprot)
7379 
    iprot.readMessageEnd()
7380 
    result = updateShipmentAddress_result()
7381 
    try:
7382 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7383 
    except TransactionServiceException, ex:
7384 
      result.ex = ex
7385 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7386 
    result.write(oprot)
7387 
    oprot.writeMessageEnd()
7388 
    oprot.trans.flush()
7389 
 
4285 rajveer 7390 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7391 
    args = acceptOrdersForItemId_args()
7392 
    args.read(iprot)
7393 
    iprot.readMessageEnd()
7394 
    result = acceptOrdersForItemId_result()
7395 
    try:
7396 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7397 
    except TransactionServiceException, ex:
7398 
      result.ex = ex
7399 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7400 
    result.write(oprot)
7401 
    oprot.writeMessageEnd()
7402 
    oprot.trans.flush()
4259 anupam.sin 7403 
 
4303 rajveer 7404 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7405 
    args = markOrdersAsPORaised_args()
7406 
    args.read(iprot)
7407 
    iprot.readMessageEnd()
7408 
    result = markOrdersAsPORaised_result()
7409 
    try:
4369 rajveer 7410 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7411 
    except TransactionServiceException, ex:
7412 
      result.ex = ex
7413 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7414 
    result.write(oprot)
7415 
    oprot.writeMessageEnd()
7416 
    oprot.trans.flush()
4285 rajveer 7417 
 
4303 rajveer 7418 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7419 
    args = markOrdersAsReversalInitiated_args()
7420 
    args.read(iprot)
7421 
    iprot.readMessageEnd()
7422 
    result = markOrdersAsReversalInitiated_result()
7423 
    try:
4369 rajveer 7424 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7425 
    except TransactionServiceException, ex:
7426 
      result.ex = ex
7427 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7428 
    result.write(oprot)
7429 
    oprot.writeMessageEnd()
7430 
    oprot.trans.flush()
7431 
 
7432 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7433 
    args = markOrdersAsNotAvailabke_args()
7434 
    args.read(iprot)
7435 
    iprot.readMessageEnd()
7436 
    result = markOrdersAsNotAvailabke_result()
7437 
    try:
4369 rajveer 7438 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7439 
    except TransactionServiceException, ex:
7440 
      result.ex = ex
7441 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7442 
    result.write(oprot)
7443 
    oprot.writeMessageEnd()
7444 
    oprot.trans.flush()
7445 
 
4369 rajveer 7446 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7447 
    args = markOrdersAsTimeout_args()
7448 
    args.read(iprot)
7449 
    iprot.readMessageEnd()
7450 
    result = markOrdersAsTimeout_result()
7451 
    try:
7452 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7453 
    except TransactionServiceException, ex:
7454 
      result.ex = ex
7455 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7456 
    result.write(oprot)
7457 
    oprot.writeMessageEnd()
7458 
    oprot.trans.flush()
4303 rajveer 7459 
 
4662 rajveer 7460 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7461 
    args = markOrderAsLostInTransit_args()
7462 
    args.read(iprot)
7463 
    iprot.readMessageEnd()
7464 
    result = markOrderAsLostInTransit_result()
7465 
    try:
7466 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7467 
    except TransactionServiceException, ex:
7468 
      result.ex = ex
7469 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7470 
    result.write(oprot)
7471 
    oprot.writeMessageEnd()
7472 
    oprot.trans.flush()
7473 
 
4386 anupam.sin 7474 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7475 
    args = getOrderForAwb_args()
7476 
    args.read(iprot)
7477 
    iprot.readMessageEnd()
7478 
    result = getOrderForAwb_result()
7479 
    try:
7480 
      result.success = self._handler.getOrderForAwb(args.awb)
7481 
    except TransactionServiceException, ex:
7482 
      result.ex = ex
7483 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7484 
    result.write(oprot)
7485 
    oprot.writeMessageEnd()
7486 
    oprot.trans.flush()
4369 rajveer 7487 
 
4506 phani.kuma 7488 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7489 
    args = getOrdersForProviderForStatus_args()
7490 
    args.read(iprot)
7491 
    iprot.readMessageEnd()
7492 
    result = getOrdersForProviderForStatus_result()
7493 
    try:
4910 phani.kuma 7494 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7495 
    except TransactionServiceException, ex:
7496 
      result.ex = ex
7497 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7498 
    result.write(oprot)
7499 
    oprot.writeMessageEnd()
7500 
    oprot.trans.flush()
4386 anupam.sin 7501 
 
4600 varun.gupt 7502 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7503 
    args = getBilledOrdersForVendor_args()
7504 
    args.read(iprot)
7505 
    iprot.readMessageEnd()
7506 
    result = getBilledOrdersForVendor_result()
7507 
    try:
7508 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7509 
    except TransactionServiceException, ex:
7510 
      result.ex = ex
7511 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7512 
    result.write(oprot)
7513 
    oprot.writeMessageEnd()
7514 
    oprot.trans.flush()
4506 phani.kuma 7515 
 
4607 rajveer 7516 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7517 
    args = getSlippedSippingDateOrders_args()
7518 
    args.read(iprot)
7519 
    iprot.readMessageEnd()
7520 
    result = getSlippedSippingDateOrders_result()
7521 
    try:
7522 
      result.success = self._handler.getSlippedSippingDateOrders()
7523 
    except TransactionServiceException, ex:
7524 
      result.ex = ex
7525 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7526 
    result.write(oprot)
7527 
    oprot.writeMessageEnd()
7528 
    oprot.trans.flush()
7529 
 
4709 rajveer 7530 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7531 
    args = getCancelledOrders_args()
7532 
    args.read(iprot)
7533 
    iprot.readMessageEnd()
7534 
    result = getCancelledOrders_result()
7535 
    try:
7536 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7537 
    except TransactionServiceException, ex:
7538 
      result.ex = ex
7539 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7540 
    result.write(oprot)
7541 
    oprot.writeMessageEnd()
7542 
    oprot.trans.flush()
7543 
 
4600 varun.gupt 7544 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7545 
    args = saveBluedartSettlements_args()
7546 
    args.read(iprot)
7547 
    iprot.readMessageEnd()
7548 
    result = saveBluedartSettlements_result()
7549 
    try:
7550 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7551 
    except TransactionServiceException, ex:
7552 
      result.ex = ex
7553 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7554 
    result.write(oprot)
7555 
    oprot.writeMessageEnd()
7556 
    oprot.trans.flush()
7557 
 
7558 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7559 
    args = savePaymentSettlements_args()
7560 
    args.read(iprot)
7561 
    iprot.readMessageEnd()
7562 
    result = savePaymentSettlements_result()
7563 
    try:
4905 varun.gupt 7564 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7565 
    except TransactionServiceException, ex:
7566 
      result.ex = ex
7567 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7568 
    result.write(oprot)
7569 
    oprot.writeMessageEnd()
7570 
    oprot.trans.flush()
7571 
 
7572 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7573 
    args = saveEBSSettlementSummary_args()
7574 
    args.read(iprot)
7575 
    iprot.readMessageEnd()
7576 
    result = saveEBSSettlementSummary_result()
7577 
    try:
7578 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7579 
    except TransactionServiceException, ex:
7580 
      result.ex = ex
7581 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7582 
    result.write(oprot)
7583 
    oprot.writeMessageEnd()
7584 
    oprot.trans.flush()
7585 
 
5386 phani.kuma 7586 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7587 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7588 
    args.read(iprot)
7589 
    iprot.readMessageEnd()
5386 phani.kuma 7590 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7591 
    try:
5386 phani.kuma 7592 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7593 
    except TransactionServiceException, ex:
7594 
      result.ex = ex
5386 phani.kuma 7595 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7596 
    result.write(oprot)
7597 
    oprot.writeMessageEnd()
7598 
    oprot.trans.flush()
7599 
 
5386 phani.kuma 7600 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7601 
    args = getSettlementForCod_args()
7602 
    args.read(iprot)
7603 
    iprot.readMessageEnd()
7604 
    result = getSettlementForCod_result()
7605 
    try:
7606 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7607 
    except TransactionServiceException, ex:
7608 
      result.ex = ex
7609 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7610 
    result.write(oprot)
7611 
    oprot.writeMessageEnd()
7612 
    oprot.trans.flush()
7613 
 
4600 varun.gupt 7614 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7615 
    args = getEBSSettlementSummaries_args()
7616 
    args.read(iprot)
7617 
    iprot.readMessageEnd()
7618 
    result = getEBSSettlementSummaries_result()
7619 
    try:
7620 
      result.success = self._handler.getEBSSettlementSummaries()
7621 
    except TransactionServiceException, ex:
7622 
      result.ex = ex
7623 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7624 
    result.write(oprot)
7625 
    oprot.writeMessageEnd()
7626 
    oprot.trans.flush()
7627 
 
7628 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7629 
    args = markEBSSettlementUploaded_args()
7630 
    args.read(iprot)
7631 
    iprot.readMessageEnd()
7632 
    result = markEBSSettlementUploaded_result()
7633 
    try:
7634 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7635 
    except TransactionServiceException, ex:
7636 
      result.ex = ex
7637 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7638 
    result.write(oprot)
7639 
    oprot.writeMessageEnd()
7640 
    oprot.trans.flush()
7641 
 
7642 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7643 
    args = getEBSSettlementDate_args()
7644 
    args.read(iprot)
7645 
    iprot.readMessageEnd()
7646 
    result = getEBSSettlementDate_result()
7647 
    try:
7648 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7649 
    except TransactionServiceException, ex:
7650 
      result.ex = ex
7651 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7652 
    result.write(oprot)
7653 
    oprot.writeMessageEnd()
7654 
    oprot.trans.flush()
7655 
 
4715 varun.gupt 7656 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7657 
    args = getSettlementsByDate_args()
7658 
    args.read(iprot)
7659 
    iprot.readMessageEnd()
7660 
    result = getSettlementsByDate_result()
7661 
    try:
7662 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7663 
    except TransactionServiceException, ex:
7664 
      result.ex = ex
7665 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7666 
    result.write(oprot)
7667 
    oprot.writeMessageEnd()
7668 
    oprot.trans.flush()
4600 varun.gupt 7669 
 
4715 varun.gupt 7670 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7671 
    args = getReshippedOrderIds_args()
7672 
    args.read(iprot)
7673 
    iprot.readMessageEnd()
7674 
    result = getReshippedOrderIds_result()
7675 
    try:
7676 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7677 
    except TransactionServiceException, ex:
7678 
      result.ex = ex
7679 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7680 
    result.write(oprot)
7681 
    oprot.writeMessageEnd()
7682 
    oprot.trans.flush()
7683 
 
5481 phani.kuma 7684 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7685 
    args = getBilledOrders_args()
4875 varun.gupt 7686 
    args.read(iprot)
7687 
    iprot.readMessageEnd()
5481 phani.kuma 7688 
    result = getBilledOrders_result()
4875 varun.gupt 7689 
    try:
5481 phani.kuma 7690 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7691 
    except TransactionServiceException, ex:
7692 
      result.ex = ex
5481 phani.kuma 7693 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7694 
    result.write(oprot)
7695 
    oprot.writeMessageEnd()
7696 
    oprot.trans.flush()
4757 mandeep.dh 7697 
 
5031 varun.gupt 7698 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7699 
    args = getStatusDistributionOfOrders_args()
7700 
    args.read(iprot)
7701 
    iprot.readMessageEnd()
7702 
    result = getStatusDistributionOfOrders_result()
7703 
    try:
7704 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7705 
    except TransactionServiceException, ex:
7706 
      result.ex = ex
7707 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7708 
    result.write(oprot)
7709 
    oprot.writeMessageEnd()
7710 
    oprot.trans.flush()
4875 varun.gupt 7711 
 
5067 varun.gupt 7712 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7713 
    args = getOrderIdsForStatus_args()
7714 
    args.read(iprot)
7715 
    iprot.readMessageEnd()
7716 
    result = getOrderIdsForStatus_result()
7717 
    try:
7718 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7719 
    except TransactionServiceException, ex:
7720 
      result.ex = ex
7721 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7722 
    result.write(oprot)
7723 
    oprot.writeMessageEnd()
7724 
    oprot.trans.flush()
5031 varun.gupt 7725 
 
5348 anupam.sin 7726 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7727 
    args = updateCODAgent_args()
7728 
    args.read(iprot)
7729 
    iprot.readMessageEnd()
7730 
    result = updateCODAgent_result()
7731 
    try:
7732 
      self._handler.updateCODAgent(args.agent, args.orderId)
7733 
    except TransactionServiceException, ex:
7734 
      result.ex = ex
7735 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7736 
    result.write(oprot)
7737 
    oprot.writeMessageEnd()
7738 
    oprot.trans.flush()
7739 
 
5099 varun.gupt 7740 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7741 
    args = updateOrderAsPaidToVendor_args()
7742 
    args.read(iprot)
7743 
    iprot.readMessageEnd()
7744 
    result = updateOrderAsPaidToVendor_result()
7745 
    try:
7746 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7747 
    except TransactionServiceException, ex:
7748 
      result.ex = ex
7749 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7750 
    result.write(oprot)
7751 
    oprot.writeMessageEnd()
7752 
    oprot.trans.flush()
5067 varun.gupt 7753 
 
5386 phani.kuma 7754 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7755 
    args = updateOrderOnlyAsPaidToVendor_args()
7756 
    args.read(iprot)
7757 
    iprot.readMessageEnd()
7758 
    result = updateOrderOnlyAsPaidToVendor_result()
7759 
    try:
7760 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7761 
    except TransactionServiceException, ex:
7762 
      result.ex = ex
7763 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7764 
    result.write(oprot)
7765 
    oprot.writeMessageEnd()
7766 
    oprot.trans.flush()
7767 
 
5208 varun.gupt 7768 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7769 
    args = getRefundedOrdersMarkedPaid_args()
7770 
    args.read(iprot)
7771 
    iprot.readMessageEnd()
7772 
    result = getRefundedOrdersMarkedPaid_result()
7773 
    try:
7774 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7775 
    except TransactionServiceException, ex:
7776 
      result.ex = ex
7777 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7778 
    result.write(oprot)
7779 
    oprot.writeMessageEnd()
7780 
    oprot.trans.flush()
5099 varun.gupt 7781 
 
5447 anupam.sin 7782 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7783 
    args = getAllVerificationAgents_args()
7784 
    args.read(iprot)
7785 
    iprot.readMessageEnd()
7786 
    result = getAllVerificationAgents_result()
7787 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7788 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7789 
    result.write(oprot)
7790 
    oprot.writeMessageEnd()
7791 
    oprot.trans.flush()
5208 varun.gupt 7792 
 
5527 anupam.sin 7793 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7794 
    args = getAllAttributesForOrderId_args()
7795 
    args.read(iprot)
7796 
    iprot.readMessageEnd()
7797 
    result = getAllAttributesForOrderId_result()
7798 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7799 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7800 
    result.write(oprot)
7801 
    oprot.writeMessageEnd()
7802 
    oprot.trans.flush()
5447 anupam.sin 7803 
 
5676 rajveer 7804 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7805 
    args = setOrderAttributes_args()
7806 
    args.read(iprot)
7807 
    iprot.readMessageEnd()
7808 
    result = setOrderAttributes_result()
7809 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7810 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7811 
    result.write(oprot)
7812 
    oprot.writeMessageEnd()
7813 
    oprot.trans.flush()
7814 
 
5527 anupam.sin 7815 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7816 
    args = setOrderAttributeForTransaction_args()
7817 
    args.read(iprot)
7818 
    iprot.readMessageEnd()
7819 
    result = setOrderAttributeForTransaction_result()
7820 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7821 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7822 
    result.write(oprot)
7823 
    oprot.writeMessageEnd()
7824 
    oprot.trans.flush()
7825 
 
5553 rajveer 7826 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7827 
    args = getReceivePendingOrders_args()
7828 
    args.read(iprot)
7829 
    iprot.readMessageEnd()
7830 
    result = getReceivePendingOrders_result()
7831 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7832 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7833 
    result.write(oprot)
7834 
    oprot.writeMessageEnd()
7835 
    oprot.trans.flush()
5527 anupam.sin 7836 
 
5553 rajveer 7837 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7838 
    args = getReceivedAtStoreOrders_args()
7839 
    args.read(iprot)
7840 
    iprot.readMessageEnd()
7841 
    result = getReceivedAtStoreOrders_result()
7842 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7843 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7844 
    result.write(oprot)
7845 
    oprot.writeMessageEnd()
7846 
    oprot.trans.flush()
7847 
 
5713 rajveer 7848 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
7849 
    args = getOrdersCollectionAtStore_args()
7850 
    args.read(iprot)
7851 
    iprot.readMessageEnd()
7852 
    result = getOrdersCollectionAtStore_result()
7853 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
7854 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
7855 
    result.write(oprot)
7856 
    oprot.writeMessageEnd()
7857 
    oprot.trans.flush()
7858 
 
5833 rajveer 7859 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
7860 
    args = getOrderAttributeValue_args()
7861 
    args.read(iprot)
7862 
    iprot.readMessageEnd()
7863 
    result = getOrderAttributeValue_result()
7864 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
7865 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
7866 
    result.write(oprot)
7867 
    oprot.writeMessageEnd()
7868 
    oprot.trans.flush()
7869 
 
6019 rajveer 7870 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
7871 
    args = changeJacketNumber_args()
7872 
    args.read(iprot)
7873 
    iprot.readMessageEnd()
7874 
    result = changeJacketNumber_result()
7875 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
7876 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
7877 
    result.write(oprot)
7878 
    oprot.writeMessageEnd()
7879 
    oprot.trans.flush()
7880 
 
7881 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
7882 
    args = markOrderAsRtoInTransit_args()
7883 
    args.read(iprot)
7884 
    iprot.readMessageEnd()
7885 
    result = markOrderAsRtoInTransit_result()
7886 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
7887 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
7888 
    result.write(oprot)
7889 
    oprot.writeMessageEnd()
7890 
    oprot.trans.flush()
7891 
 
5593 mandeep.dh 7892 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7893 
    args = acceptOrderForItem_args()
7894 
    args.read(iprot)
7895 
    iprot.readMessageEnd()
7896 
    result = acceptOrderForItem_result()
7897 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7898 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7899 
    result.write(oprot)
7900 
    oprot.writeMessageEnd()
7901 
    oprot.trans.flush()
5553 rajveer 7902 
 
6000 mandeep.dh 7903 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
7904 
    args = createRechargeOrder_args()
7905 
    args.read(iprot)
7906 
    iprot.readMessageEnd()
7907 
    result = createRechargeOrder_result()
7908 
    try:
7909 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
7910 
    except TransactionServiceException, ex:
7911 
      result.ex = ex
7912 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
7913 
    result.write(oprot)
7914 
    oprot.writeMessageEnd()
7915 
    oprot.trans.flush()
5593 mandeep.dh 7916 
 
6031 rajveer 7917 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
7918 
    args = getRechargeOrder_args()
7919 
    args.read(iprot)
7920 
    iprot.readMessageEnd()
7921 
    result = getRechargeOrder_result()
7922 
    try:
7923 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
7924 
    except TransactionServiceException, ex:
7925 
      result.ex = ex
7926 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
7927 
    result.write(oprot)
7928 
    oprot.writeMessageEnd()
7929 
    oprot.trans.flush()
7930 
 
7931 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
7932 
    args = getRechargeOrders_args()
7933 
    args.read(iprot)
7934 
    iprot.readMessageEnd()
7935 
    result = getRechargeOrders_result()
7936 
    result.success = self._handler.getRechargeOrders(args.userId)
7937 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
7938 
    result.write(oprot)
7939 
    oprot.writeMessageEnd()
7940 
    oprot.trans.flush()
7941 
 
6000 mandeep.dh 7942 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
7943 
    args = updateRechargeOrderStatus_args()
7944 
    args.read(iprot)
7945 
    iprot.readMessageEnd()
7946 
    result = updateRechargeOrderStatus_result()
7947 
    try:
6031 rajveer 7948 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 7949 
    except TransactionServiceException, ex:
7950 
      result.ex = ex
7951 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
7952 
    result.write(oprot)
7953 
    oprot.writeMessageEnd()
7954 
    oprot.trans.flush()
7955 
 
7956 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
7957 
    args = activateRechargeTxn_args()
7958 
    args.read(iprot)
7959 
    iprot.readMessageEnd()
7960 
    result = activateRechargeTxn_result()
7961 
    try:
6031 rajveer 7962 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 7963 
    except TransactionServiceException, ex:
7964 
      result.ex = ex
7965 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
7966 
    result.write(oprot)
7967 
    oprot.writeMessageEnd()
7968 
    oprot.trans.flush()
7969 
 
6031 rajveer 7970 
  def process_getUserWallet(self, seqid, iprot, oprot):
7971 
    args = getUserWallet_args()
6000 mandeep.dh 7972 
    args.read(iprot)
7973 
    iprot.readMessageEnd()
6031 rajveer 7974 
    result = getUserWallet_result()
7975 
    result.success = self._handler.getUserWallet(args.userId)
7976 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 7977 
    result.write(oprot)
7978 
    oprot.writeMessageEnd()
7979 
    oprot.trans.flush()
7980 
 
6031 rajveer 7981 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
7982 
    args = getUserWalletHistory_args()
6000 mandeep.dh 7983 
    args.read(iprot)
7984 
    iprot.readMessageEnd()
6031 rajveer 7985 
    result = getUserWalletHistory_result()
7986 
    result.success = self._handler.getUserWalletHistory(args.userId)
7987 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 7988 
    result.write(oprot)
7989 
    oprot.writeMessageEnd()
7990 
    oprot.trans.flush()
7991 
 
6048 rajveer 7992 
  def process_getServiceProviders(self, seqid, iprot, oprot):
7993 
    args = getServiceProviders_args()
7994 
    args.read(iprot)
7995 
    iprot.readMessageEnd()
7996 
    result = getServiceProviders_result()
7997 
    result.success = self._handler.getServiceProviders(args.rechargeType)
7998 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
7999 
    result.write(oprot)
8000 
    oprot.writeMessageEnd()
8001 
    oprot.trans.flush()
6000 mandeep.dh 8002 
 
6048 rajveer 8003 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8004 
    args = getServiceProviderForDevice_args()
8005 
    args.read(iprot)
8006 
    iprot.readMessageEnd()
8007 
    result = getServiceProviderForDevice_result()
6049 rajveer 8008 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8009 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8010 
    result.write(oprot)
8011 
    oprot.writeMessageEnd()
8012 
    oprot.trans.flush()
8013 
 
8014 
 
94 ashish 8015 
# HELPER FUNCTIONS AND STRUCTURES
8016 
 
8017 
class createTransaction_args:
8018 
  """
8019 
  Attributes:
8020 
   - transaction
8021 
  """
8022 
 
8023 
  thrift_spec = (
8024 
    None, # 0
8025 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8026 
  )
8027 
 
8028 
  def __init__(self, transaction=None,):
8029 
    self.transaction = transaction
8030 
 
8031 
  def read(self, iprot):
8032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8034 
      return
8035 
    iprot.readStructBegin()
8036 
    while True:
8037 
      (fname, ftype, fid) = iprot.readFieldBegin()
8038 
      if ftype == TType.STOP:
8039 
        break
8040 
      if fid == 1:
8041 
        if ftype == TType.STRUCT:
8042 
          self.transaction = Transaction()
8043 
          self.transaction.read(iprot)
8044 
        else:
8045 
          iprot.skip(ftype)
8046 
      else:
8047 
        iprot.skip(ftype)
8048 
      iprot.readFieldEnd()
8049 
    iprot.readStructEnd()
8050 
 
8051 
  def write(self, oprot):
8052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8054 
      return
8055 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8056 
    if self.transaction is not None:
94 ashish 8057 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8058 
      self.transaction.write(oprot)
8059 
      oprot.writeFieldEnd()
8060 
    oprot.writeFieldStop()
8061 
    oprot.writeStructEnd()
8062 
 
3431 rajveer 8063 
  def validate(self):
8064 
    return
8065 
 
8066 
 
94 ashish 8067 
  def __repr__(self):
8068 
    L = ['%s=%r' % (key, value)
8069 
      for key, value in self.__dict__.iteritems()]
8070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8071 
 
8072 
  def __eq__(self, other):
8073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8074 
 
8075 
  def __ne__(self, other):
8076 
    return not (self == other)
8077 
 
8078 
class createTransaction_result:
8079 
  """
8080 
  Attributes:
132 ashish 8081 
   - success
94 ashish 8082 
   - ex
8083 
  """
8084 
 
8085 
  thrift_spec = (
132 ashish 8086 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8087 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8088 
  )
8089 
 
132 ashish 8090 
  def __init__(self, success=None, ex=None,):
8091 
    self.success = success
94 ashish 8092 
    self.ex = ex
8093 
 
8094 
  def read(self, iprot):
8095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8097 
      return
8098 
    iprot.readStructBegin()
8099 
    while True:
8100 
      (fname, ftype, fid) = iprot.readFieldBegin()
8101 
      if ftype == TType.STOP:
8102 
        break
132 ashish 8103 
      if fid == 0:
8104 
        if ftype == TType.I64:
8105 
          self.success = iprot.readI64();
8106 
        else:
8107 
          iprot.skip(ftype)
8108 
      elif fid == 1:
94 ashish 8109 
        if ftype == TType.STRUCT:
8110 
          self.ex = TransactionServiceException()
8111 
          self.ex.read(iprot)
8112 
        else:
8113 
          iprot.skip(ftype)
8114 
      else:
8115 
        iprot.skip(ftype)
8116 
      iprot.readFieldEnd()
8117 
    iprot.readStructEnd()
8118 
 
8119 
  def write(self, oprot):
8120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8122 
      return
8123 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8124 
    if self.success is not None:
132 ashish 8125 
      oprot.writeFieldBegin('success', TType.I64, 0)
8126 
      oprot.writeI64(self.success)
8127 
      oprot.writeFieldEnd()
3431 rajveer 8128 
    if self.ex is not None:
94 ashish 8129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8130 
      self.ex.write(oprot)
8131 
      oprot.writeFieldEnd()
8132 
    oprot.writeFieldStop()
8133 
    oprot.writeStructEnd()
8134 
 
3431 rajveer 8135 
  def validate(self):
8136 
    return
8137 
 
8138 
 
94 ashish 8139 
  def __repr__(self):
8140 
    L = ['%s=%r' % (key, value)
8141 
      for key, value in self.__dict__.iteritems()]
8142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8143 
 
8144 
  def __eq__(self, other):
8145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8146 
 
8147 
  def __ne__(self, other):
8148 
    return not (self == other)
8149 
 
8150 
class getTransaction_args:
8151 
  """
8152 
  Attributes:
8153 
   - id
8154 
  """
8155 
 
8156 
  thrift_spec = (
8157 
    None, # 0
8158 
    (1, TType.I64, 'id', None, None, ), # 1
8159 
  )
8160 
 
8161 
  def __init__(self, id=None,):
8162 
    self.id = id
8163 
 
8164 
  def read(self, iprot):
8165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8167 
      return
8168 
    iprot.readStructBegin()
8169 
    while True:
8170 
      (fname, ftype, fid) = iprot.readFieldBegin()
8171 
      if ftype == TType.STOP:
8172 
        break
8173 
      if fid == 1:
8174 
        if ftype == TType.I64:
8175 
          self.id = iprot.readI64();
8176 
        else:
8177 
          iprot.skip(ftype)
8178 
      else:
8179 
        iprot.skip(ftype)
8180 
      iprot.readFieldEnd()
8181 
    iprot.readStructEnd()
8182 
 
8183 
  def write(self, oprot):
8184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8186 
      return
8187 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8188 
    if self.id is not None:
94 ashish 8189 
      oprot.writeFieldBegin('id', TType.I64, 1)
8190 
      oprot.writeI64(self.id)
8191 
      oprot.writeFieldEnd()
8192 
    oprot.writeFieldStop()
8193 
    oprot.writeStructEnd()
8194 
 
3431 rajveer 8195 
  def validate(self):
8196 
    return
8197 
 
8198 
 
94 ashish 8199 
  def __repr__(self):
8200 
    L = ['%s=%r' % (key, value)
8201 
      for key, value in self.__dict__.iteritems()]
8202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8203 
 
8204 
  def __eq__(self, other):
8205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8206 
 
8207 
  def __ne__(self, other):
8208 
    return not (self == other)
8209 
 
8210 
class getTransaction_result:
8211 
  """
8212 
  Attributes:
8213 
   - success
8214 
   - ex
8215 
  """
8216 
 
8217 
  thrift_spec = (
8218 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8219 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8220 
  )
8221 
 
8222 
  def __init__(self, success=None, ex=None,):
8223 
    self.success = success
8224 
    self.ex = ex
8225 
 
8226 
  def read(self, iprot):
8227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8229 
      return
8230 
    iprot.readStructBegin()
8231 
    while True:
8232 
      (fname, ftype, fid) = iprot.readFieldBegin()
8233 
      if ftype == TType.STOP:
8234 
        break
8235 
      if fid == 0:
8236 
        if ftype == TType.STRUCT:
8237 
          self.success = Transaction()
8238 
          self.success.read(iprot)
8239 
        else:
8240 
          iprot.skip(ftype)
8241 
      elif fid == 1:
8242 
        if ftype == TType.STRUCT:
8243 
          self.ex = TransactionServiceException()
8244 
          self.ex.read(iprot)
8245 
        else:
8246 
          iprot.skip(ftype)
8247 
      else:
8248 
        iprot.skip(ftype)
8249 
      iprot.readFieldEnd()
8250 
    iprot.readStructEnd()
8251 
 
8252 
  def write(self, oprot):
8253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8255 
      return
8256 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8257 
    if self.success is not None:
94 ashish 8258 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8259 
      self.success.write(oprot)
8260 
      oprot.writeFieldEnd()
3431 rajveer 8261 
    if self.ex is not None:
94 ashish 8262 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8263 
      self.ex.write(oprot)
8264 
      oprot.writeFieldEnd()
8265 
    oprot.writeFieldStop()
8266 
    oprot.writeStructEnd()
8267 
 
3431 rajveer 8268 
  def validate(self):
8269 
    return
8270 
 
8271 
 
94 ashish 8272 
  def __repr__(self):
8273 
    L = ['%s=%r' % (key, value)
8274 
      for key, value in self.__dict__.iteritems()]
8275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8276 
 
8277 
  def __eq__(self, other):
8278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8279 
 
8280 
  def __ne__(self, other):
8281 
    return not (self == other)
8282 
 
8283 
class getTransactionsForCustomer_args:
8284 
  """
8285 
  Attributes:
8286 
   - customerId
8287 
   - from_date
8288 
   - to_date
8289 
   - status
8290 
  """
8291 
 
8292 
  thrift_spec = (
8293 
    None, # 0
8294 
    (1, TType.I64, 'customerId', None, None, ), # 1
8295 
    (2, TType.I64, 'from_date', None, None, ), # 2
8296 
    (3, TType.I64, 'to_date', None, None, ), # 3
8297 
    (4, TType.I32, 'status', None, None, ), # 4
8298 
  )
8299 
 
8300 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8301 
    self.customerId = customerId
8302 
    self.from_date = from_date
8303 
    self.to_date = to_date
8304 
    self.status = status
8305 
 
8306 
  def read(self, iprot):
8307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8309 
      return
8310 
    iprot.readStructBegin()
8311 
    while True:
8312 
      (fname, ftype, fid) = iprot.readFieldBegin()
8313 
      if ftype == TType.STOP:
8314 
        break
8315 
      if fid == 1:
8316 
        if ftype == TType.I64:
8317 
          self.customerId = iprot.readI64();
8318 
        else:
8319 
          iprot.skip(ftype)
8320 
      elif fid == 2:
8321 
        if ftype == TType.I64:
8322 
          self.from_date = iprot.readI64();
8323 
        else:
8324 
          iprot.skip(ftype)
8325 
      elif fid == 3:
8326 
        if ftype == TType.I64:
8327 
          self.to_date = iprot.readI64();
8328 
        else:
8329 
          iprot.skip(ftype)
8330 
      elif fid == 4:
8331 
        if ftype == TType.I32:
8332 
          self.status = iprot.readI32();
8333 
        else:
8334 
          iprot.skip(ftype)
8335 
      else:
8336 
        iprot.skip(ftype)
8337 
      iprot.readFieldEnd()
8338 
    iprot.readStructEnd()
8339 
 
8340 
  def write(self, oprot):
8341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8343 
      return
8344 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8345 
    if self.customerId is not None:
94 ashish 8346 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8347 
      oprot.writeI64(self.customerId)
8348 
      oprot.writeFieldEnd()
3431 rajveer 8349 
    if self.from_date is not None:
94 ashish 8350 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8351 
      oprot.writeI64(self.from_date)
8352 
      oprot.writeFieldEnd()
3431 rajveer 8353 
    if self.to_date is not None:
94 ashish 8354 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8355 
      oprot.writeI64(self.to_date)
8356 
      oprot.writeFieldEnd()
3431 rajveer 8357 
    if self.status is not None:
94 ashish 8358 
      oprot.writeFieldBegin('status', TType.I32, 4)
8359 
      oprot.writeI32(self.status)
8360 
      oprot.writeFieldEnd()
8361 
    oprot.writeFieldStop()
8362 
    oprot.writeStructEnd()
8363 
 
3431 rajveer 8364 
  def validate(self):
8365 
    return
8366 
 
8367 
 
94 ashish 8368 
  def __repr__(self):
8369 
    L = ['%s=%r' % (key, value)
8370 
      for key, value in self.__dict__.iteritems()]
8371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8372 
 
8373 
  def __eq__(self, other):
8374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8375 
 
8376 
  def __ne__(self, other):
8377 
    return not (self == other)
8378 
 
8379 
class getTransactionsForCustomer_result:
8380 
  """
8381 
  Attributes:
8382 
   - success
8383 
   - ex
8384 
  """
8385 
 
8386 
  thrift_spec = (
8387 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8388 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8389 
  )
8390 
 
8391 
  def __init__(self, success=None, ex=None,):
8392 
    self.success = success
8393 
    self.ex = ex
8394 
 
8395 
  def read(self, iprot):
8396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8398 
      return
8399 
    iprot.readStructBegin()
8400 
    while True:
8401 
      (fname, ftype, fid) = iprot.readFieldBegin()
8402 
      if ftype == TType.STOP:
8403 
        break
8404 
      if fid == 0:
8405 
        if ftype == TType.LIST:
8406 
          self.success = []
6031 rajveer 8407 
          (_etype66, _size63) = iprot.readListBegin()
8408 
          for _i67 in xrange(_size63):
8409 
            _elem68 = Transaction()
8410 
            _elem68.read(iprot)
8411 
            self.success.append(_elem68)
94 ashish 8412 
          iprot.readListEnd()
8413 
        else:
8414 
          iprot.skip(ftype)
8415 
      elif fid == 1:
8416 
        if ftype == TType.STRUCT:
8417 
          self.ex = TransactionServiceException()
8418 
          self.ex.read(iprot)
8419 
        else:
8420 
          iprot.skip(ftype)
8421 
      else:
8422 
        iprot.skip(ftype)
8423 
      iprot.readFieldEnd()
8424 
    iprot.readStructEnd()
8425 
 
8426 
  def write(self, oprot):
8427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8429 
      return
8430 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8431 
    if self.success is not None:
94 ashish 8432 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8433 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8434 
      for iter69 in self.success:
8435 
        iter69.write(oprot)
94 ashish 8436 
      oprot.writeListEnd()
8437 
      oprot.writeFieldEnd()
3431 rajveer 8438 
    if self.ex is not None:
94 ashish 8439 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8440 
      self.ex.write(oprot)
8441 
      oprot.writeFieldEnd()
8442 
    oprot.writeFieldStop()
8443 
    oprot.writeStructEnd()
8444 
 
3431 rajveer 8445 
  def validate(self):
8446 
    return
8447 
 
8448 
 
94 ashish 8449 
  def __repr__(self):
8450 
    L = ['%s=%r' % (key, value)
8451 
      for key, value in self.__dict__.iteritems()]
8452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8453 
 
8454 
  def __eq__(self, other):
8455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8456 
 
8457 
  def __ne__(self, other):
8458 
    return not (self == other)
8459 
 
132 ashish 8460 
class getTransactionsForShoppingCartId_args:
8461 
  """
8462 
  Attributes:
8463 
   - shoppingCartId
8464 
  """
8465 
 
8466 
  thrift_spec = (
8467 
    None, # 0
8468 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8469 
  )
8470 
 
8471 
  def __init__(self, shoppingCartId=None,):
8472 
    self.shoppingCartId = shoppingCartId
8473 
 
8474 
  def read(self, iprot):
8475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8477 
      return
8478 
    iprot.readStructBegin()
8479 
    while True:
8480 
      (fname, ftype, fid) = iprot.readFieldBegin()
8481 
      if ftype == TType.STOP:
8482 
        break
8483 
      if fid == 1:
8484 
        if ftype == TType.I64:
8485 
          self.shoppingCartId = iprot.readI64();
8486 
        else:
8487 
          iprot.skip(ftype)
8488 
      else:
8489 
        iprot.skip(ftype)
8490 
      iprot.readFieldEnd()
8491 
    iprot.readStructEnd()
8492 
 
8493 
  def write(self, oprot):
8494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8496 
      return
8497 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8498 
    if self.shoppingCartId is not None:
132 ashish 8499 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8500 
      oprot.writeI64(self.shoppingCartId)
8501 
      oprot.writeFieldEnd()
8502 
    oprot.writeFieldStop()
8503 
    oprot.writeStructEnd()
8504 
 
3431 rajveer 8505 
  def validate(self):
8506 
    return
8507 
 
8508 
 
132 ashish 8509 
  def __repr__(self):
8510 
    L = ['%s=%r' % (key, value)
8511 
      for key, value in self.__dict__.iteritems()]
8512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8513 
 
8514 
  def __eq__(self, other):
8515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8516 
 
8517 
  def __ne__(self, other):
8518 
    return not (self == other)
8519 
 
8520 
class getTransactionsForShoppingCartId_result:
8521 
  """
8522 
  Attributes:
8523 
   - success
8524 
   - ex
8525 
  """
8526 
 
8527 
  thrift_spec = (
8528 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8529 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8530 
  )
8531 
 
8532 
  def __init__(self, success=None, ex=None,):
8533 
    self.success = success
8534 
    self.ex = ex
8535 
 
8536 
  def read(self, iprot):
8537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8539 
      return
8540 
    iprot.readStructBegin()
8541 
    while True:
8542 
      (fname, ftype, fid) = iprot.readFieldBegin()
8543 
      if ftype == TType.STOP:
8544 
        break
8545 
      if fid == 0:
8546 
        if ftype == TType.LIST:
8547 
          self.success = []
6031 rajveer 8548 
          (_etype73, _size70) = iprot.readListBegin()
8549 
          for _i74 in xrange(_size70):
8550 
            _elem75 = Transaction()
8551 
            _elem75.read(iprot)
8552 
            self.success.append(_elem75)
132 ashish 8553 
          iprot.readListEnd()
8554 
        else:
8555 
          iprot.skip(ftype)
8556 
      elif fid == 1:
8557 
        if ftype == TType.STRUCT:
8558 
          self.ex = TransactionServiceException()
8559 
          self.ex.read(iprot)
8560 
        else:
8561 
          iprot.skip(ftype)
8562 
      else:
8563 
        iprot.skip(ftype)
8564 
      iprot.readFieldEnd()
8565 
    iprot.readStructEnd()
8566 
 
8567 
  def write(self, oprot):
8568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8570 
      return
8571 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8572 
    if self.success is not None:
132 ashish 8573 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8574 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8575 
      for iter76 in self.success:
8576 
        iter76.write(oprot)
132 ashish 8577 
      oprot.writeListEnd()
8578 
      oprot.writeFieldEnd()
3431 rajveer 8579 
    if self.ex is not None:
132 ashish 8580 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8581 
      self.ex.write(oprot)
8582 
      oprot.writeFieldEnd()
8583 
    oprot.writeFieldStop()
8584 
    oprot.writeStructEnd()
8585 
 
3431 rajveer 8586 
  def validate(self):
8587 
    return
8588 
 
8589 
 
132 ashish 8590 
  def __repr__(self):
8591 
    L = ['%s=%r' % (key, value)
8592 
      for key, value in self.__dict__.iteritems()]
8593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8594 
 
8595 
  def __eq__(self, other):
8596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8597 
 
8598 
  def __ne__(self, other):
8599 
    return not (self == other)
8600 
 
94 ashish 8601 
class getTransactionStatus_args:
8602 
  """
8603 
  Attributes:
8604 
   - transactionId
8605 
  """
8606 
 
8607 
  thrift_spec = (
8608 
    None, # 0
8609 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8610 
  )
8611 
 
8612 
  def __init__(self, transactionId=None,):
8613 
    self.transactionId = transactionId
8614 
 
8615 
  def read(self, iprot):
8616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8618 
      return
8619 
    iprot.readStructBegin()
8620 
    while True:
8621 
      (fname, ftype, fid) = iprot.readFieldBegin()
8622 
      if ftype == TType.STOP:
8623 
        break
8624 
      if fid == 1:
8625 
        if ftype == TType.I64:
8626 
          self.transactionId = iprot.readI64();
8627 
        else:
8628 
          iprot.skip(ftype)
8629 
      else:
8630 
        iprot.skip(ftype)
8631 
      iprot.readFieldEnd()
8632 
    iprot.readStructEnd()
8633 
 
8634 
  def write(self, oprot):
8635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8637 
      return
8638 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8639 
    if self.transactionId is not None:
94 ashish 8640 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8641 
      oprot.writeI64(self.transactionId)
8642 
      oprot.writeFieldEnd()
8643 
    oprot.writeFieldStop()
8644 
    oprot.writeStructEnd()
8645 
 
3431 rajveer 8646 
  def validate(self):
8647 
    return
8648 
 
8649 
 
94 ashish 8650 
  def __repr__(self):
8651 
    L = ['%s=%r' % (key, value)
8652 
      for key, value in self.__dict__.iteritems()]
8653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8654 
 
8655 
  def __eq__(self, other):
8656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8657 
 
8658 
  def __ne__(self, other):
8659 
    return not (self == other)
8660 
 
8661 
class getTransactionStatus_result:
8662 
  """
8663 
  Attributes:
8664 
   - success
8665 
   - ex
8666 
  """
8667 
 
8668 
  thrift_spec = (
8669 
    (0, TType.I32, 'success', None, None, ), # 0
8670 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8671 
  )
8672 
 
8673 
  def __init__(self, success=None, ex=None,):
8674 
    self.success = success
8675 
    self.ex = ex
8676 
 
8677 
  def read(self, iprot):
8678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8680 
      return
8681 
    iprot.readStructBegin()
8682 
    while True:
8683 
      (fname, ftype, fid) = iprot.readFieldBegin()
8684 
      if ftype == TType.STOP:
8685 
        break
8686 
      if fid == 0:
8687 
        if ftype == TType.I32:
8688 
          self.success = iprot.readI32();
8689 
        else:
8690 
          iprot.skip(ftype)
8691 
      elif fid == 1:
8692 
        if ftype == TType.STRUCT:
8693 
          self.ex = TransactionServiceException()
8694 
          self.ex.read(iprot)
8695 
        else:
8696 
          iprot.skip(ftype)
8697 
      else:
8698 
        iprot.skip(ftype)
8699 
      iprot.readFieldEnd()
8700 
    iprot.readStructEnd()
8701 
 
8702 
  def write(self, oprot):
8703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8705 
      return
8706 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8707 
    if self.success is not None:
94 ashish 8708 
      oprot.writeFieldBegin('success', TType.I32, 0)
8709 
      oprot.writeI32(self.success)
8710 
      oprot.writeFieldEnd()
3431 rajveer 8711 
    if self.ex is not None:
94 ashish 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 
 
94 ashish 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 
 
8733 
class changeTransactionStatus_args:
8734 
  """
8735 
  Attributes:
8736 
   - transactionId
8737 
   - status
8738 
   - description
5527 anupam.sin 8739 
   - pickUp
8740 
   - orderType
94 ashish 8741 
  """
8742 
 
8743 
  thrift_spec = (
8744 
    None, # 0
8745 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8746 
    (2, TType.I32, 'status', None, None, ), # 2
8747 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8748 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8749 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8750 
  )
8751 
 
5527 anupam.sin 8752 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8753 
    self.transactionId = transactionId
8754 
    self.status = status
8755 
    self.description = description
5527 anupam.sin 8756 
    self.pickUp = pickUp
8757 
    self.orderType = orderType
94 ashish 8758 
 
8759 
  def read(self, iprot):
8760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8762 
      return
8763 
    iprot.readStructBegin()
8764 
    while True:
8765 
      (fname, ftype, fid) = iprot.readFieldBegin()
8766 
      if ftype == TType.STOP:
8767 
        break
8768 
      if fid == 1:
8769 
        if ftype == TType.I64:
8770 
          self.transactionId = iprot.readI64();
8771 
        else:
8772 
          iprot.skip(ftype)
8773 
      elif fid == 2:
8774 
        if ftype == TType.I32:
8775 
          self.status = iprot.readI32();
8776 
        else:
8777 
          iprot.skip(ftype)
8778 
      elif fid == 3:
8779 
        if ftype == TType.STRING:
8780 
          self.description = iprot.readString();
8781 
        else:
8782 
          iprot.skip(ftype)
5387 rajveer 8783 
      elif fid == 4:
5527 anupam.sin 8784 
        if ftype == TType.I64:
8785 
          self.pickUp = iprot.readI64();
5387 rajveer 8786 
        else:
8787 
          iprot.skip(ftype)
5527 anupam.sin 8788 
      elif fid == 5:
8789 
        if ftype == TType.I32:
8790 
          self.orderType = iprot.readI32();
8791 
        else:
8792 
          iprot.skip(ftype)
94 ashish 8793 
      else:
8794 
        iprot.skip(ftype)
8795 
      iprot.readFieldEnd()
8796 
    iprot.readStructEnd()
8797 
 
8798 
  def write(self, oprot):
8799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8801 
      return
8802 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8803 
    if self.transactionId is not None:
94 ashish 8804 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8805 
      oprot.writeI64(self.transactionId)
8806 
      oprot.writeFieldEnd()
3431 rajveer 8807 
    if self.status is not None:
94 ashish 8808 
      oprot.writeFieldBegin('status', TType.I32, 2)
8809 
      oprot.writeI32(self.status)
8810 
      oprot.writeFieldEnd()
3431 rajveer 8811 
    if self.description is not None:
94 ashish 8812 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8813 
      oprot.writeString(self.description)
8814 
      oprot.writeFieldEnd()
5527 anupam.sin 8815 
    if self.pickUp is not None:
8816 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8817 
      oprot.writeI64(self.pickUp)
5387 rajveer 8818 
      oprot.writeFieldEnd()
5527 anupam.sin 8819 
    if self.orderType is not None:
8820 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8821 
      oprot.writeI32(self.orderType)
8822 
      oprot.writeFieldEnd()
94 ashish 8823 
    oprot.writeFieldStop()
8824 
    oprot.writeStructEnd()
8825 
 
3431 rajveer 8826 
  def validate(self):
8827 
    return
8828 
 
8829 
 
94 ashish 8830 
  def __repr__(self):
8831 
    L = ['%s=%r' % (key, value)
8832 
      for key, value in self.__dict__.iteritems()]
8833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8834 
 
8835 
  def __eq__(self, other):
8836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8837 
 
8838 
  def __ne__(self, other):
8839 
    return not (self == other)
8840 
 
8841 
class changeTransactionStatus_result:
8842 
  """
8843 
  Attributes:
8844 
   - success
8845 
   - ex
8846 
  """
8847 
 
8848 
  thrift_spec = (
8849 
    (0, TType.BOOL, 'success', None, None, ), # 0
8850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8851 
  )
8852 
 
8853 
  def __init__(self, success=None, ex=None,):
8854 
    self.success = success
8855 
    self.ex = ex
8856 
 
8857 
  def read(self, iprot):
8858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8860 
      return
8861 
    iprot.readStructBegin()
8862 
    while True:
8863 
      (fname, ftype, fid) = iprot.readFieldBegin()
8864 
      if ftype == TType.STOP:
8865 
        break
8866 
      if fid == 0:
8867 
        if ftype == TType.BOOL:
8868 
          self.success = iprot.readBool();
8869 
        else:
8870 
          iprot.skip(ftype)
8871 
      elif fid == 1:
8872 
        if ftype == TType.STRUCT:
8873 
          self.ex = TransactionServiceException()
8874 
          self.ex.read(iprot)
8875 
        else:
8876 
          iprot.skip(ftype)
8877 
      else:
8878 
        iprot.skip(ftype)
8879 
      iprot.readFieldEnd()
8880 
    iprot.readStructEnd()
8881 
 
8882 
  def write(self, oprot):
8883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8885 
      return
8886 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8887 
    if self.success is not None:
94 ashish 8888 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8889 
      oprot.writeBool(self.success)
8890 
      oprot.writeFieldEnd()
3431 rajveer 8891 
    if self.ex is not None:
94 ashish 8892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8893 
      self.ex.write(oprot)
8894 
      oprot.writeFieldEnd()
8895 
    oprot.writeFieldStop()
8896 
    oprot.writeStructEnd()
8897 
 
3431 rajveer 8898 
  def validate(self):
8899 
    return
8900 
 
8901 
 
94 ashish 8902 
  def __repr__(self):
8903 
    L = ['%s=%r' % (key, value)
8904 
      for key, value in self.__dict__.iteritems()]
8905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8906 
 
8907 
  def __eq__(self, other):
8908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8909 
 
8910 
  def __ne__(self, other):
8911 
    return not (self == other)
8912 
 
1398 varun.gupt 8913 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8914 
  """
8915 
  Attributes:
8916 
   - transactionId
8917 
  """
8918 
 
8919 
  thrift_spec = (
8920 
    None, # 0
8921 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8922 
  )
8923 
 
8924 
  def __init__(self, transactionId=None,):
8925 
    self.transactionId = transactionId
8926 
 
8927 
  def read(self, iprot):
8928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8930 
      return
8931 
    iprot.readStructBegin()
8932 
    while True:
8933 
      (fname, ftype, fid) = iprot.readFieldBegin()
8934 
      if ftype == TType.STOP:
8935 
        break
8936 
      if fid == 1:
8937 
        if ftype == TType.I64:
8938 
          self.transactionId = iprot.readI64();
8939 
        else:
8940 
          iprot.skip(ftype)
8941 
      else:
8942 
        iprot.skip(ftype)
8943 
      iprot.readFieldEnd()
8944 
    iprot.readStructEnd()
8945 
 
8946 
  def write(self, oprot):
8947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8949 
      return
1398 varun.gupt 8950 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8951 
    if self.transactionId is not None:
1382 varun.gupt 8952 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8953 
      oprot.writeI64(self.transactionId)
8954 
      oprot.writeFieldEnd()
8955 
    oprot.writeFieldStop()
8956 
    oprot.writeStructEnd()
8957 
 
3431 rajveer 8958 
  def validate(self):
8959 
    return
8960 
 
8961 
 
1382 varun.gupt 8962 
  def __repr__(self):
8963 
    L = ['%s=%r' % (key, value)
8964 
      for key, value in self.__dict__.iteritems()]
8965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8966 
 
8967 
  def __eq__(self, other):
8968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8969 
 
8970 
  def __ne__(self, other):
8971 
    return not (self == other)
8972 
 
1398 varun.gupt 8973 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8974 
  """
8975 
  Attributes:
8976 
   - success
8977 
   - ex
8978 
  """
8979 
 
8980 
  thrift_spec = (
8981 
    (0, TType.BOOL, 'success', None, None, ), # 0
8982 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8983 
  )
8984 
 
8985 
  def __init__(self, success=None, ex=None,):
8986 
    self.success = success
8987 
    self.ex = ex
8988 
 
8989 
  def read(self, iprot):
8990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8992 
      return
8993 
    iprot.readStructBegin()
8994 
    while True:
8995 
      (fname, ftype, fid) = iprot.readFieldBegin()
8996 
      if ftype == TType.STOP:
8997 
        break
8998 
      if fid == 0:
8999 
        if ftype == TType.BOOL:
9000 
          self.success = iprot.readBool();
9001 
        else:
9002 
          iprot.skip(ftype)
9003 
      elif fid == 1:
9004 
        if ftype == TType.STRUCT:
9005 
          self.ex = TransactionServiceException()
9006 
          self.ex.read(iprot)
9007 
        else:
9008 
          iprot.skip(ftype)
9009 
      else:
9010 
        iprot.skip(ftype)
9011 
      iprot.readFieldEnd()
9012 
    iprot.readStructEnd()
9013 
 
9014 
  def write(self, oprot):
9015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9017 
      return
1398 varun.gupt 9018 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9019 
    if self.success is not None:
1382 varun.gupt 9020 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9021 
      oprot.writeBool(self.success)
9022 
      oprot.writeFieldEnd()
3431 rajveer 9023 
    if self.ex is not None:
1382 varun.gupt 9024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9025 
      self.ex.write(oprot)
9026 
      oprot.writeFieldEnd()
9027 
    oprot.writeFieldStop()
9028 
    oprot.writeStructEnd()
9029 
 
3431 rajveer 9030 
  def validate(self):
9031 
    return
9032 
 
9033 
 
1382 varun.gupt 9034 
  def __repr__(self):
9035 
    L = ['%s=%r' % (key, value)
9036 
      for key, value in self.__dict__.iteritems()]
9037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9038 
 
9039 
  def __eq__(self, other):
9040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9041 
 
9042 
  def __ne__(self, other):
9043 
    return not (self == other)
9044 
 
483 rajveer 9045 
class getAllOrders_args:
94 ashish 9046 
  """
9047 
  Attributes:
4801 anupam.sin 9048 
   - statuses
483 rajveer 9049 
   - from_date
9050 
   - to_date
9051 
   - warehouse_id
94 ashish 9052 
  """
9053 
 
9054 
  thrift_spec = (
9055 
    None, # 0
4801 anupam.sin 9056 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9057 
    (2, TType.I64, 'from_date', None, None, ), # 2
9058 
    (3, TType.I64, 'to_date', None, None, ), # 3
9059 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9060 
  )
9061 
 
4801 anupam.sin 9062 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9063 
    self.statuses = statuses
483 rajveer 9064 
    self.from_date = from_date
9065 
    self.to_date = to_date
9066 
    self.warehouse_id = warehouse_id
94 ashish 9067 
 
9068 
  def read(self, iprot):
9069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9071 
      return
9072 
    iprot.readStructBegin()
9073 
    while True:
9074 
      (fname, ftype, fid) = iprot.readFieldBegin()
9075 
      if ftype == TType.STOP:
9076 
        break
9077 
      if fid == 1:
4801 anupam.sin 9078 
        if ftype == TType.LIST:
9079 
          self.statuses = []
6031 rajveer 9080 
          (_etype80, _size77) = iprot.readListBegin()
9081 
          for _i81 in xrange(_size77):
9082 
            _elem82 = iprot.readI32();
9083 
            self.statuses.append(_elem82)
4801 anupam.sin 9084 
          iprot.readListEnd()
94 ashish 9085 
        else:
9086 
          iprot.skip(ftype)
483 rajveer 9087 
      elif fid == 2:
9088 
        if ftype == TType.I64:
9089 
          self.from_date = iprot.readI64();
94 ashish 9090 
        else:
9091 
          iprot.skip(ftype)
483 rajveer 9092 
      elif fid == 3:
9093 
        if ftype == TType.I64:
9094 
          self.to_date = iprot.readI64();
94 ashish 9095 
        else:
9096 
          iprot.skip(ftype)
483 rajveer 9097 
      elif fid == 4:
94 ashish 9098 
        if ftype == TType.I64:
483 rajveer 9099 
          self.warehouse_id = iprot.readI64();
94 ashish 9100 
        else:
9101 
          iprot.skip(ftype)
9102 
      else:
9103 
        iprot.skip(ftype)
9104 
      iprot.readFieldEnd()
9105 
    iprot.readStructEnd()
9106 
 
9107 
  def write(self, oprot):
9108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9110 
      return
483 rajveer 9111 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9112 
    if self.statuses is not None:
9113 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9114 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9115 
      for iter83 in self.statuses:
9116 
        oprot.writeI32(iter83)
4801 anupam.sin 9117 
      oprot.writeListEnd()
94 ashish 9118 
      oprot.writeFieldEnd()
3431 rajveer 9119 
    if self.from_date is not None:
483 rajveer 9120 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9121 
      oprot.writeI64(self.from_date)
94 ashish 9122 
      oprot.writeFieldEnd()
3431 rajveer 9123 
    if self.to_date is not None:
483 rajveer 9124 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9125 
      oprot.writeI64(self.to_date)
94 ashish 9126 
      oprot.writeFieldEnd()
3431 rajveer 9127 
    if self.warehouse_id is not None:
483 rajveer 9128 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9129 
      oprot.writeI64(self.warehouse_id)
94 ashish 9130 
      oprot.writeFieldEnd()
9131 
    oprot.writeFieldStop()
9132 
    oprot.writeStructEnd()
9133 
 
3431 rajveer 9134 
  def validate(self):
9135 
    return
9136 
 
9137 
 
94 ashish 9138 
  def __repr__(self):
9139 
    L = ['%s=%r' % (key, value)
9140 
      for key, value in self.__dict__.iteritems()]
9141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9142 
 
9143 
  def __eq__(self, other):
9144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9145 
 
9146 
  def __ne__(self, other):
9147 
    return not (self == other)
9148 
 
483 rajveer 9149 
class getAllOrders_result:
94 ashish 9150 
  """
9151 
  Attributes:
9152 
   - success
9153 
   - ex
9154 
  """
9155 
 
9156 
  thrift_spec = (
483 rajveer 9157 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9158 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9159 
  )
9160 
 
9161 
  def __init__(self, success=None, ex=None,):
9162 
    self.success = success
9163 
    self.ex = ex
9164 
 
9165 
  def read(self, iprot):
9166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9168 
      return
9169 
    iprot.readStructBegin()
9170 
    while True:
9171 
      (fname, ftype, fid) = iprot.readFieldBegin()
9172 
      if ftype == TType.STOP:
9173 
        break
9174 
      if fid == 0:
483 rajveer 9175 
        if ftype == TType.LIST:
9176 
          self.success = []
6031 rajveer 9177 
          (_etype87, _size84) = iprot.readListBegin()
9178 
          for _i88 in xrange(_size84):
9179 
            _elem89 = Order()
9180 
            _elem89.read(iprot)
9181 
            self.success.append(_elem89)
483 rajveer 9182 
          iprot.readListEnd()
94 ashish 9183 
        else:
9184 
          iprot.skip(ftype)
9185 
      elif fid == 1:
9186 
        if ftype == TType.STRUCT:
9187 
          self.ex = TransactionServiceException()
9188 
          self.ex.read(iprot)
9189 
        else:
9190 
          iprot.skip(ftype)
9191 
      else:
9192 
        iprot.skip(ftype)
9193 
      iprot.readFieldEnd()
9194 
    iprot.readStructEnd()
9195 
 
9196 
  def write(self, oprot):
9197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9199 
      return
483 rajveer 9200 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9201 
    if self.success is not None:
483 rajveer 9202 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9203 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9204 
      for iter90 in self.success:
9205 
        iter90.write(oprot)
483 rajveer 9206 
      oprot.writeListEnd()
94 ashish 9207 
      oprot.writeFieldEnd()
3431 rajveer 9208 
    if self.ex is not None:
94 ashish 9209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9210 
      self.ex.write(oprot)
9211 
      oprot.writeFieldEnd()
9212 
    oprot.writeFieldStop()
9213 
    oprot.writeStructEnd()
9214 
 
3431 rajveer 9215 
  def validate(self):
9216 
    return
9217 
 
9218 
 
94 ashish 9219 
  def __repr__(self):
9220 
    L = ['%s=%r' % (key, value)
9221 
      for key, value in self.__dict__.iteritems()]
9222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9223 
 
9224 
  def __eq__(self, other):
9225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9226 
 
9227 
  def __ne__(self, other):
9228 
    return not (self == other)
9229 
 
4133 chandransh 9230 
class getOrdersInBatch_args:
9231 
  """
9232 
  Attributes:
9233 
   - statuses
9234 
   - offset
9235 
   - limit
9236 
   - warehouse_id
9237 
  """
9238 
 
9239 
  thrift_spec = (
9240 
    None, # 0
9241 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9242 
    (2, TType.I64, 'offset', None, None, ), # 2
9243 
    (3, TType.I64, 'limit', None, None, ), # 3
9244 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9245 
  )
9246 
 
9247 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9248 
    self.statuses = statuses
9249 
    self.offset = offset
9250 
    self.limit = limit
9251 
    self.warehouse_id = warehouse_id
9252 
 
9253 
  def read(self, iprot):
9254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9256 
      return
9257 
    iprot.readStructBegin()
9258 
    while True:
9259 
      (fname, ftype, fid) = iprot.readFieldBegin()
9260 
      if ftype == TType.STOP:
9261 
        break
9262 
      if fid == 1:
9263 
        if ftype == TType.LIST:
9264 
          self.statuses = []
6031 rajveer 9265 
          (_etype94, _size91) = iprot.readListBegin()
9266 
          for _i95 in xrange(_size91):
9267 
            _elem96 = iprot.readI32();
9268 
            self.statuses.append(_elem96)
4133 chandransh 9269 
          iprot.readListEnd()
9270 
        else:
9271 
          iprot.skip(ftype)
9272 
      elif fid == 2:
9273 
        if ftype == TType.I64:
9274 
          self.offset = iprot.readI64();
9275 
        else:
9276 
          iprot.skip(ftype)
9277 
      elif fid == 3:
9278 
        if ftype == TType.I64:
9279 
          self.limit = iprot.readI64();
9280 
        else:
9281 
          iprot.skip(ftype)
9282 
      elif fid == 4:
9283 
        if ftype == TType.I64:
9284 
          self.warehouse_id = iprot.readI64();
9285 
        else:
9286 
          iprot.skip(ftype)
9287 
      else:
9288 
        iprot.skip(ftype)
9289 
      iprot.readFieldEnd()
9290 
    iprot.readStructEnd()
9291 
 
9292 
  def write(self, oprot):
9293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9295 
      return
9296 
    oprot.writeStructBegin('getOrdersInBatch_args')
9297 
    if self.statuses is not None:
9298 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9299 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9300 
      for iter97 in self.statuses:
9301 
        oprot.writeI32(iter97)
4133 chandransh 9302 
      oprot.writeListEnd()
9303 
      oprot.writeFieldEnd()
9304 
    if self.offset is not None:
9305 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9306 
      oprot.writeI64(self.offset)
9307 
      oprot.writeFieldEnd()
9308 
    if self.limit is not None:
9309 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9310 
      oprot.writeI64(self.limit)
9311 
      oprot.writeFieldEnd()
9312 
    if self.warehouse_id is not None:
9313 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9314 
      oprot.writeI64(self.warehouse_id)
9315 
      oprot.writeFieldEnd()
9316 
    oprot.writeFieldStop()
9317 
    oprot.writeStructEnd()
9318 
 
9319 
  def validate(self):
9320 
    return
9321 
 
9322 
 
9323 
  def __repr__(self):
9324 
    L = ['%s=%r' % (key, value)
9325 
      for key, value in self.__dict__.iteritems()]
9326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9327 
 
9328 
  def __eq__(self, other):
9329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9330 
 
9331 
  def __ne__(self, other):
9332 
    return not (self == other)
9333 
 
9334 
class getOrdersInBatch_result:
9335 
  """
9336 
  Attributes:
9337 
   - success
9338 
   - ex
9339 
  """
9340 
 
9341 
  thrift_spec = (
9342 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9343 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9344 
  )
9345 
 
9346 
  def __init__(self, success=None, ex=None,):
9347 
    self.success = success
9348 
    self.ex = ex
9349 
 
9350 
  def read(self, iprot):
9351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9353 
      return
9354 
    iprot.readStructBegin()
9355 
    while True:
9356 
      (fname, ftype, fid) = iprot.readFieldBegin()
9357 
      if ftype == TType.STOP:
9358 
        break
9359 
      if fid == 0:
9360 
        if ftype == TType.LIST:
9361 
          self.success = []
6031 rajveer 9362 
          (_etype101, _size98) = iprot.readListBegin()
9363 
          for _i102 in xrange(_size98):
9364 
            _elem103 = Order()
9365 
            _elem103.read(iprot)
9366 
            self.success.append(_elem103)
4133 chandransh 9367 
          iprot.readListEnd()
9368 
        else:
9369 
          iprot.skip(ftype)
9370 
      elif fid == 1:
9371 
        if ftype == TType.STRUCT:
9372 
          self.ex = TransactionServiceException()
9373 
          self.ex.read(iprot)
9374 
        else:
9375 
          iprot.skip(ftype)
9376 
      else:
9377 
        iprot.skip(ftype)
9378 
      iprot.readFieldEnd()
9379 
    iprot.readStructEnd()
9380 
 
9381 
  def write(self, oprot):
9382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9384 
      return
9385 
    oprot.writeStructBegin('getOrdersInBatch_result')
9386 
    if self.success is not None:
9387 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9388 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9389 
      for iter104 in self.success:
9390 
        iter104.write(oprot)
4133 chandransh 9391 
      oprot.writeListEnd()
9392 
      oprot.writeFieldEnd()
9393 
    if self.ex is not None:
9394 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9395 
      self.ex.write(oprot)
9396 
      oprot.writeFieldEnd()
9397 
    oprot.writeFieldStop()
9398 
    oprot.writeStructEnd()
9399 
 
9400 
  def validate(self):
9401 
    return
9402 
 
9403 
 
9404 
  def __repr__(self):
9405 
    L = ['%s=%r' % (key, value)
9406 
      for key, value in self.__dict__.iteritems()]
9407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9408 
 
9409 
  def __eq__(self, other):
9410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9411 
 
9412 
  def __ne__(self, other):
9413 
    return not (self == other)
9414 
 
9415 
class getOrderCount_args:
9416 
  """
9417 
  Attributes:
9418 
   - statuses
9419 
   - warehouseId
9420 
  """
9421 
 
9422 
  thrift_spec = (
9423 
    None, # 0
9424 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9425 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9426 
  )
9427 
 
9428 
  def __init__(self, statuses=None, warehouseId=None,):
9429 
    self.statuses = statuses
9430 
    self.warehouseId = warehouseId
9431 
 
9432 
  def read(self, iprot):
9433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9435 
      return
9436 
    iprot.readStructBegin()
9437 
    while True:
9438 
      (fname, ftype, fid) = iprot.readFieldBegin()
9439 
      if ftype == TType.STOP:
9440 
        break
9441 
      if fid == 1:
9442 
        if ftype == TType.LIST:
9443 
          self.statuses = []
6031 rajveer 9444 
          (_etype108, _size105) = iprot.readListBegin()
9445 
          for _i109 in xrange(_size105):
9446 
            _elem110 = iprot.readI32();
9447 
            self.statuses.append(_elem110)
4133 chandransh 9448 
          iprot.readListEnd()
9449 
        else:
9450 
          iprot.skip(ftype)
9451 
      elif fid == 2:
9452 
        if ftype == TType.I64:
9453 
          self.warehouseId = iprot.readI64();
9454 
        else:
9455 
          iprot.skip(ftype)
9456 
      else:
9457 
        iprot.skip(ftype)
9458 
      iprot.readFieldEnd()
9459 
    iprot.readStructEnd()
9460 
 
9461 
  def write(self, oprot):
9462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9464 
      return
9465 
    oprot.writeStructBegin('getOrderCount_args')
9466 
    if self.statuses is not None:
9467 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9468 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9469 
      for iter111 in self.statuses:
9470 
        oprot.writeI32(iter111)
4133 chandransh 9471 
      oprot.writeListEnd()
9472 
      oprot.writeFieldEnd()
9473 
    if self.warehouseId is not None:
9474 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9475 
      oprot.writeI64(self.warehouseId)
9476 
      oprot.writeFieldEnd()
9477 
    oprot.writeFieldStop()
9478 
    oprot.writeStructEnd()
9479 
 
9480 
  def validate(self):
9481 
    return
9482 
 
9483 
 
9484 
  def __repr__(self):
9485 
    L = ['%s=%r' % (key, value)
9486 
      for key, value in self.__dict__.iteritems()]
9487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9488 
 
9489 
  def __eq__(self, other):
9490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9491 
 
9492 
  def __ne__(self, other):
9493 
    return not (self == other)
9494 
 
9495 
class getOrderCount_result:
9496 
  """
9497 
  Attributes:
9498 
   - success
9499 
   - ex
9500 
  """
9501 
 
9502 
  thrift_spec = (
9503 
    (0, TType.I32, 'success', None, None, ), # 0
9504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9505 
  )
9506 
 
9507 
  def __init__(self, success=None, ex=None,):
9508 
    self.success = success
9509 
    self.ex = ex
9510 
 
9511 
  def read(self, iprot):
9512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9514 
      return
9515 
    iprot.readStructBegin()
9516 
    while True:
9517 
      (fname, ftype, fid) = iprot.readFieldBegin()
9518 
      if ftype == TType.STOP:
9519 
        break
9520 
      if fid == 0:
9521 
        if ftype == TType.I32:
9522 
          self.success = iprot.readI32();
9523 
        else:
9524 
          iprot.skip(ftype)
9525 
      elif fid == 1:
9526 
        if ftype == TType.STRUCT:
9527 
          self.ex = TransactionServiceException()
9528 
          self.ex.read(iprot)
9529 
        else:
9530 
          iprot.skip(ftype)
9531 
      else:
9532 
        iprot.skip(ftype)
9533 
      iprot.readFieldEnd()
9534 
    iprot.readStructEnd()
9535 
 
9536 
  def write(self, oprot):
9537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9539 
      return
9540 
    oprot.writeStructBegin('getOrderCount_result')
9541 
    if self.success is not None:
9542 
      oprot.writeFieldBegin('success', TType.I32, 0)
9543 
      oprot.writeI32(self.success)
9544 
      oprot.writeFieldEnd()
9545 
    if self.ex is not None:
9546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9547 
      self.ex.write(oprot)
9548 
      oprot.writeFieldEnd()
9549 
    oprot.writeFieldStop()
9550 
    oprot.writeStructEnd()
9551 
 
9552 
  def validate(self):
9553 
    return
9554 
 
9555 
 
9556 
  def __repr__(self):
9557 
    L = ['%s=%r' % (key, value)
9558 
      for key, value in self.__dict__.iteritems()]
9559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9560 
 
9561 
  def __eq__(self, other):
9562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9563 
 
9564 
  def __ne__(self, other):
9565 
    return not (self == other)
9566 
 
999 varun.gupt 9567 
class getOrdersByBillingDate_args:
9568 
  """
9569 
  Attributes:
9570 
   - status
9571 
   - start_billing_date
9572 
   - end_billing_date
9573 
   - warehouse_id
9574 
  """
9575 
 
9576 
  thrift_spec = (
9577 
    None, # 0
9578 
    (1, TType.I32, 'status', None, None, ), # 1
9579 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9580 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9581 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9582 
  )
9583 
 
9584 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9585 
    self.status = status
9586 
    self.start_billing_date = start_billing_date
9587 
    self.end_billing_date = end_billing_date
9588 
    self.warehouse_id = warehouse_id
9589 
 
9590 
  def read(self, iprot):
9591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9593 
      return
9594 
    iprot.readStructBegin()
9595 
    while True:
9596 
      (fname, ftype, fid) = iprot.readFieldBegin()
9597 
      if ftype == TType.STOP:
9598 
        break
9599 
      if fid == 1:
9600 
        if ftype == TType.I32:
9601 
          self.status = iprot.readI32();
9602 
        else:
9603 
          iprot.skip(ftype)
9604 
      elif fid == 2:
9605 
        if ftype == TType.I64:
9606 
          self.start_billing_date = iprot.readI64();
9607 
        else:
9608 
          iprot.skip(ftype)
9609 
      elif fid == 3:
9610 
        if ftype == TType.I64:
9611 
          self.end_billing_date = iprot.readI64();
9612 
        else:
9613 
          iprot.skip(ftype)
9614 
      elif fid == 4:
9615 
        if ftype == TType.I64:
9616 
          self.warehouse_id = iprot.readI64();
9617 
        else:
9618 
          iprot.skip(ftype)
9619 
      else:
9620 
        iprot.skip(ftype)
9621 
      iprot.readFieldEnd()
9622 
    iprot.readStructEnd()
9623 
 
9624 
  def write(self, oprot):
9625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9627 
      return
9628 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9629 
    if self.status is not None:
999 varun.gupt 9630 
      oprot.writeFieldBegin('status', TType.I32, 1)
9631 
      oprot.writeI32(self.status)
9632 
      oprot.writeFieldEnd()
3431 rajveer 9633 
    if self.start_billing_date is not None:
999 varun.gupt 9634 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9635 
      oprot.writeI64(self.start_billing_date)
9636 
      oprot.writeFieldEnd()
3431 rajveer 9637 
    if self.end_billing_date is not None:
999 varun.gupt 9638 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9639 
      oprot.writeI64(self.end_billing_date)
9640 
      oprot.writeFieldEnd()
3431 rajveer 9641 
    if self.warehouse_id is not None:
999 varun.gupt 9642 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9643 
      oprot.writeI64(self.warehouse_id)
9644 
      oprot.writeFieldEnd()
9645 
    oprot.writeFieldStop()
9646 
    oprot.writeStructEnd()
9647 
 
3431 rajveer 9648 
  def validate(self):
9649 
    return
9650 
 
9651 
 
999 varun.gupt 9652 
  def __repr__(self):
9653 
    L = ['%s=%r' % (key, value)
9654 
      for key, value in self.__dict__.iteritems()]
9655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9656 
 
9657 
  def __eq__(self, other):
9658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9659 
 
9660 
  def __ne__(self, other):
9661 
    return not (self == other)
9662 
 
9663 
class getOrdersByBillingDate_result:
9664 
  """
9665 
  Attributes:
9666 
   - success
9667 
   - ex
9668 
  """
9669 
 
9670 
  thrift_spec = (
9671 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9672 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9673 
  )
9674 
 
9675 
  def __init__(self, success=None, ex=None,):
9676 
    self.success = success
9677 
    self.ex = ex
9678 
 
9679 
  def read(self, iprot):
9680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9682 
      return
9683 
    iprot.readStructBegin()
9684 
    while True:
9685 
      (fname, ftype, fid) = iprot.readFieldBegin()
9686 
      if ftype == TType.STOP:
9687 
        break
9688 
      if fid == 0:
9689 
        if ftype == TType.LIST:
9690 
          self.success = []
6031 rajveer 9691 
          (_etype115, _size112) = iprot.readListBegin()
9692 
          for _i116 in xrange(_size112):
9693 
            _elem117 = Order()
9694 
            _elem117.read(iprot)
9695 
            self.success.append(_elem117)
999 varun.gupt 9696 
          iprot.readListEnd()
9697 
        else:
9698 
          iprot.skip(ftype)
9699 
      elif fid == 1:
9700 
        if ftype == TType.STRUCT:
9701 
          self.ex = TransactionServiceException()
9702 
          self.ex.read(iprot)
9703 
        else:
9704 
          iprot.skip(ftype)
9705 
      else:
9706 
        iprot.skip(ftype)
9707 
      iprot.readFieldEnd()
9708 
    iprot.readStructEnd()
9709 
 
9710 
  def write(self, oprot):
9711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9713 
      return
9714 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9715 
    if self.success is not None:
999 varun.gupt 9716 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9717 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9718 
      for iter118 in self.success:
9719 
        iter118.write(oprot)
999 varun.gupt 9720 
      oprot.writeListEnd()
9721 
      oprot.writeFieldEnd()
3431 rajveer 9722 
    if self.ex is not None:
999 varun.gupt 9723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9724 
      self.ex.write(oprot)
9725 
      oprot.writeFieldEnd()
9726 
    oprot.writeFieldStop()
9727 
    oprot.writeStructEnd()
9728 
 
3431 rajveer 9729 
  def validate(self):
9730 
    return
9731 
 
9732 
 
999 varun.gupt 9733 
  def __repr__(self):
9734 
    L = ['%s=%r' % (key, value)
9735 
      for key, value in self.__dict__.iteritems()]
9736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9737 
 
9738 
  def __eq__(self, other):
9739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9740 
 
9741 
  def __ne__(self, other):
9742 
    return not (self == other)
9743 
 
3427 chandransh 9744 
class getOrdersByShippingDate_args:
9745 
  """
9746 
  Attributes:
9747 
   - fromShippingDate
9748 
   - toShippingDate
9749 
   - providerId
9750 
   - warehouseId
3451 chandransh 9751 
   - cod
3427 chandransh 9752 
  """
9753 
 
9754 
  thrift_spec = (
9755 
    None, # 0
9756 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9757 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9758 
    (3, TType.I64, 'providerId', None, None, ), # 3
9759 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9760 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9761 
  )
9762 
 
3451 chandransh 9763 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9764 
    self.fromShippingDate = fromShippingDate
9765 
    self.toShippingDate = toShippingDate
9766 
    self.providerId = providerId
9767 
    self.warehouseId = warehouseId
3451 chandransh 9768 
    self.cod = cod
3427 chandransh 9769 
 
9770 
  def read(self, iprot):
9771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9773 
      return
9774 
    iprot.readStructBegin()
9775 
    while True:
9776 
      (fname, ftype, fid) = iprot.readFieldBegin()
9777 
      if ftype == TType.STOP:
9778 
        break
9779 
      if fid == 1:
9780 
        if ftype == TType.I64:
9781 
          self.fromShippingDate = iprot.readI64();
9782 
        else:
9783 
          iprot.skip(ftype)
9784 
      elif fid == 2:
9785 
        if ftype == TType.I64:
9786 
          self.toShippingDate = iprot.readI64();
9787 
        else:
9788 
          iprot.skip(ftype)
9789 
      elif fid == 3:
9790 
        if ftype == TType.I64:
9791 
          self.providerId = iprot.readI64();
9792 
        else:
9793 
          iprot.skip(ftype)
9794 
      elif fid == 4:
9795 
        if ftype == TType.I64:
9796 
          self.warehouseId = iprot.readI64();
9797 
        else:
9798 
          iprot.skip(ftype)
3451 chandransh 9799 
      elif fid == 5:
9800 
        if ftype == TType.BOOL:
9801 
          self.cod = iprot.readBool();
9802 
        else:
9803 
          iprot.skip(ftype)
3427 chandransh 9804 
      else:
9805 
        iprot.skip(ftype)
9806 
      iprot.readFieldEnd()
9807 
    iprot.readStructEnd()
9808 
 
9809 
  def write(self, oprot):
9810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9812 
      return
9813 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9814 
    if self.fromShippingDate is not None:
3427 chandransh 9815 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9816 
      oprot.writeI64(self.fromShippingDate)
9817 
      oprot.writeFieldEnd()
3431 rajveer 9818 
    if self.toShippingDate is not None:
3427 chandransh 9819 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9820 
      oprot.writeI64(self.toShippingDate)
9821 
      oprot.writeFieldEnd()
3431 rajveer 9822 
    if self.providerId is not None:
3427 chandransh 9823 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9824 
      oprot.writeI64(self.providerId)
9825 
      oprot.writeFieldEnd()
3431 rajveer 9826 
    if self.warehouseId is not None:
3427 chandransh 9827 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9828 
      oprot.writeI64(self.warehouseId)
9829 
      oprot.writeFieldEnd()
3451 chandransh 9830 
    if self.cod is not None:
9831 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9832 
      oprot.writeBool(self.cod)
9833 
      oprot.writeFieldEnd()
3427 chandransh 9834 
    oprot.writeFieldStop()
9835 
    oprot.writeStructEnd()
9836 
 
3431 rajveer 9837 
  def validate(self):
9838 
    return
9839 
 
9840 
 
3427 chandransh 9841 
  def __repr__(self):
9842 
    L = ['%s=%r' % (key, value)
9843 
      for key, value in self.__dict__.iteritems()]
9844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9845 
 
9846 
  def __eq__(self, other):
9847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9848 
 
9849 
  def __ne__(self, other):
9850 
    return not (self == other)
9851 
 
9852 
class getOrdersByShippingDate_result:
9853 
  """
9854 
  Attributes:
9855 
   - success
9856 
   - ex
9857 
  """
9858 
 
9859 
  thrift_spec = (
9860 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9862 
  )
9863 
 
9864 
  def __init__(self, success=None, ex=None,):
9865 
    self.success = success
9866 
    self.ex = ex
9867 
 
9868 
  def read(self, iprot):
9869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9871 
      return
9872 
    iprot.readStructBegin()
9873 
    while True:
9874 
      (fname, ftype, fid) = iprot.readFieldBegin()
9875 
      if ftype == TType.STOP:
9876 
        break
9877 
      if fid == 0:
9878 
        if ftype == TType.LIST:
9879 
          self.success = []
6031 rajveer 9880 
          (_etype122, _size119) = iprot.readListBegin()
9881 
          for _i123 in xrange(_size119):
9882 
            _elem124 = Order()
9883 
            _elem124.read(iprot)
9884 
            self.success.append(_elem124)
3427 chandransh 9885 
          iprot.readListEnd()
9886 
        else:
9887 
          iprot.skip(ftype)
9888 
      elif fid == 1:
9889 
        if ftype == TType.STRUCT:
9890 
          self.ex = TransactionServiceException()
9891 
          self.ex.read(iprot)
9892 
        else:
9893 
          iprot.skip(ftype)
9894 
      else:
9895 
        iprot.skip(ftype)
9896 
      iprot.readFieldEnd()
9897 
    iprot.readStructEnd()
9898 
 
9899 
  def write(self, oprot):
9900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9902 
      return
9903 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9904 
    if self.success is not None:
3427 chandransh 9905 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9906 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9907 
      for iter125 in self.success:
9908 
        iter125.write(oprot)
3427 chandransh 9909 
      oprot.writeListEnd()
9910 
      oprot.writeFieldEnd()
3431 rajveer 9911 
    if self.ex is not None:
3427 chandransh 9912 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9913 
      self.ex.write(oprot)
9914 
      oprot.writeFieldEnd()
9915 
    oprot.writeFieldStop()
9916 
    oprot.writeStructEnd()
9917 
 
3431 rajveer 9918 
  def validate(self):
9919 
    return
9920 
 
9921 
 
3427 chandransh 9922 
  def __repr__(self):
9923 
    L = ['%s=%r' % (key, value)
9924 
      for key, value in self.__dict__.iteritems()]
9925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9926 
 
9927 
  def __eq__(self, other):
9928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9929 
 
9930 
  def __ne__(self, other):
9931 
    return not (self == other)
9932 
 
1382 varun.gupt 9933 
class getReturnableOrdersForCustomer_args:
9934 
  """
9935 
  Attributes:
9936 
   - customer_id
9937 
   - limit
9938 
  """
9939 
 
9940 
  thrift_spec = (
9941 
    None, # 0
9942 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9943 
    (2, TType.I64, 'limit', None, None, ), # 2
9944 
  )
9945 
 
9946 
  def __init__(self, customer_id=None, limit=None,):
9947 
    self.customer_id = customer_id
9948 
    self.limit = limit
9949 
 
9950 
  def read(self, iprot):
9951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9953 
      return
9954 
    iprot.readStructBegin()
9955 
    while True:
9956 
      (fname, ftype, fid) = iprot.readFieldBegin()
9957 
      if ftype == TType.STOP:
9958 
        break
9959 
      if fid == 1:
9960 
        if ftype == TType.I64:
9961 
          self.customer_id = iprot.readI64();
9962 
        else:
9963 
          iprot.skip(ftype)
9964 
      elif fid == 2:
9965 
        if ftype == TType.I64:
9966 
          self.limit = iprot.readI64();
9967 
        else:
9968 
          iprot.skip(ftype)
9969 
      else:
9970 
        iprot.skip(ftype)
9971 
      iprot.readFieldEnd()
9972 
    iprot.readStructEnd()
9973 
 
9974 
  def write(self, oprot):
9975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9977 
      return
9978 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9979 
    if self.customer_id is not None:
1382 varun.gupt 9980 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9981 
      oprot.writeI64(self.customer_id)
9982 
      oprot.writeFieldEnd()
3431 rajveer 9983 
    if self.limit is not None:
1382 varun.gupt 9984 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9985 
      oprot.writeI64(self.limit)
9986 
      oprot.writeFieldEnd()
9987 
    oprot.writeFieldStop()
9988 
    oprot.writeStructEnd()
9989 
 
3431 rajveer 9990 
  def validate(self):
9991 
    return
9992 
 
9993 
 
1382 varun.gupt 9994 
  def __repr__(self):
9995 
    L = ['%s=%r' % (key, value)
9996 
      for key, value in self.__dict__.iteritems()]
9997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9998 
 
9999 
  def __eq__(self, other):
10000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10001 
 
10002 
  def __ne__(self, other):
10003 
    return not (self == other)
10004 
 
10005 
class getReturnableOrdersForCustomer_result:
10006 
  """
10007 
  Attributes:
10008 
   - success
10009 
   - ex
10010 
  """
10011 
 
10012 
  thrift_spec = (
10013 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10014 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10015 
  )
10016 
 
10017 
  def __init__(self, success=None, ex=None,):
10018 
    self.success = success
10019 
    self.ex = ex
10020 
 
10021 
  def read(self, iprot):
10022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10024 
      return
10025 
    iprot.readStructBegin()
10026 
    while True:
10027 
      (fname, ftype, fid) = iprot.readFieldBegin()
10028 
      if ftype == TType.STOP:
10029 
        break
10030 
      if fid == 0:
10031 
        if ftype == TType.LIST:
10032 
          self.success = []
6031 rajveer 10033 
          (_etype129, _size126) = iprot.readListBegin()
10034 
          for _i130 in xrange(_size126):
10035 
            _elem131 = iprot.readI64();
10036 
            self.success.append(_elem131)
1382 varun.gupt 10037 
          iprot.readListEnd()
10038 
        else:
10039 
          iprot.skip(ftype)
10040 
      elif fid == 1:
10041 
        if ftype == TType.STRUCT:
10042 
          self.ex = TransactionServiceException()
10043 
          self.ex.read(iprot)
10044 
        else:
10045 
          iprot.skip(ftype)
10046 
      else:
10047 
        iprot.skip(ftype)
10048 
      iprot.readFieldEnd()
10049 
    iprot.readStructEnd()
10050 
 
10051 
  def write(self, oprot):
10052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10054 
      return
10055 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10056 
    if self.success is not None:
1382 varun.gupt 10057 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10058 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10059 
      for iter132 in self.success:
10060 
        oprot.writeI64(iter132)
1382 varun.gupt 10061 
      oprot.writeListEnd()
10062 
      oprot.writeFieldEnd()
3431 rajveer 10063 
    if self.ex is not None:
1382 varun.gupt 10064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10065 
      self.ex.write(oprot)
10066 
      oprot.writeFieldEnd()
10067 
    oprot.writeFieldStop()
10068 
    oprot.writeStructEnd()
10069 
 
3431 rajveer 10070 
  def validate(self):
10071 
    return
10072 
 
10073 
 
1382 varun.gupt 10074 
  def __repr__(self):
10075 
    L = ['%s=%r' % (key, value)
10076 
      for key, value in self.__dict__.iteritems()]
10077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10078 
 
10079 
  def __eq__(self, other):
10080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10081 
 
10082 
  def __ne__(self, other):
10083 
    return not (self == other)
10084 
 
10085 
class getCancellableOrdersForCustomer_args:
10086 
  """
10087 
  Attributes:
10088 
   - customer_id
10089 
   - limit
10090 
  """
10091 
 
10092 
  thrift_spec = (
10093 
    None, # 0
10094 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10095 
    (2, TType.I64, 'limit', None, None, ), # 2
10096 
  )
10097 
 
10098 
  def __init__(self, customer_id=None, limit=None,):
10099 
    self.customer_id = customer_id
10100 
    self.limit = limit
10101 
 
10102 
  def read(self, iprot):
10103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10105 
      return
10106 
    iprot.readStructBegin()
10107 
    while True:
10108 
      (fname, ftype, fid) = iprot.readFieldBegin()
10109 
      if ftype == TType.STOP:
10110 
        break
10111 
      if fid == 1:
10112 
        if ftype == TType.I64:
10113 
          self.customer_id = iprot.readI64();
10114 
        else:
10115 
          iprot.skip(ftype)
10116 
      elif fid == 2:
10117 
        if ftype == TType.I64:
10118 
          self.limit = iprot.readI64();
10119 
        else:
10120 
          iprot.skip(ftype)
10121 
      else:
10122 
        iprot.skip(ftype)
10123 
      iprot.readFieldEnd()
10124 
    iprot.readStructEnd()
10125 
 
10126 
  def write(self, oprot):
10127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10129 
      return
10130 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10131 
    if self.customer_id is not None:
1382 varun.gupt 10132 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10133 
      oprot.writeI64(self.customer_id)
10134 
      oprot.writeFieldEnd()
3431 rajveer 10135 
    if self.limit is not None:
1382 varun.gupt 10136 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10137 
      oprot.writeI64(self.limit)
10138 
      oprot.writeFieldEnd()
10139 
    oprot.writeFieldStop()
10140 
    oprot.writeStructEnd()
10141 
 
3431 rajveer 10142 
  def validate(self):
10143 
    return
10144 
 
10145 
 
1382 varun.gupt 10146 
  def __repr__(self):
10147 
    L = ['%s=%r' % (key, value)
10148 
      for key, value in self.__dict__.iteritems()]
10149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10150 
 
10151 
  def __eq__(self, other):
10152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10153 
 
10154 
  def __ne__(self, other):
10155 
    return not (self == other)
10156 
 
10157 
class getCancellableOrdersForCustomer_result:
10158 
  """
10159 
  Attributes:
10160 
   - success
10161 
   - ex
10162 
  """
10163 
 
10164 
  thrift_spec = (
10165 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10167 
  )
10168 
 
10169 
  def __init__(self, success=None, ex=None,):
10170 
    self.success = success
10171 
    self.ex = ex
10172 
 
10173 
  def read(self, iprot):
10174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10176 
      return
10177 
    iprot.readStructBegin()
10178 
    while True:
10179 
      (fname, ftype, fid) = iprot.readFieldBegin()
10180 
      if ftype == TType.STOP:
10181 
        break
10182 
      if fid == 0:
10183 
        if ftype == TType.LIST:
10184 
          self.success = []
6031 rajveer 10185 
          (_etype136, _size133) = iprot.readListBegin()
10186 
          for _i137 in xrange(_size133):
10187 
            _elem138 = iprot.readI64();
10188 
            self.success.append(_elem138)
1382 varun.gupt 10189 
          iprot.readListEnd()
10190 
        else:
10191 
          iprot.skip(ftype)
10192 
      elif fid == 1:
10193 
        if ftype == TType.STRUCT:
10194 
          self.ex = TransactionServiceException()
10195 
          self.ex.read(iprot)
10196 
        else:
10197 
          iprot.skip(ftype)
10198 
      else:
10199 
        iprot.skip(ftype)
10200 
      iprot.readFieldEnd()
10201 
    iprot.readStructEnd()
10202 
 
10203 
  def write(self, oprot):
10204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10206 
      return
10207 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10208 
    if self.success is not None:
1382 varun.gupt 10209 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10210 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10211 
      for iter139 in self.success:
10212 
        oprot.writeI64(iter139)
1382 varun.gupt 10213 
      oprot.writeListEnd()
10214 
      oprot.writeFieldEnd()
3431 rajveer 10215 
    if self.ex is not None:
1382 varun.gupt 10216 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10217 
      self.ex.write(oprot)
10218 
      oprot.writeFieldEnd()
10219 
    oprot.writeFieldStop()
10220 
    oprot.writeStructEnd()
10221 
 
3431 rajveer 10222 
  def validate(self):
10223 
    return
10224 
 
10225 
 
1382 varun.gupt 10226 
  def __repr__(self):
10227 
    L = ['%s=%r' % (key, value)
10228 
      for key, value in self.__dict__.iteritems()]
10229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10230 
 
10231 
  def __eq__(self, other):
10232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10233 
 
10234 
  def __ne__(self, other):
10235 
    return not (self == other)
10236 
 
483 rajveer 10237 
class changeOrderStatus_args:
94 ashish 10238 
  """
10239 
  Attributes:
483 rajveer 10240 
   - orderId
10241 
   - status
10242 
   - description
94 ashish 10243 
  """
10244 
 
10245 
  thrift_spec = (
10246 
    None, # 0
483 rajveer 10247 
    (1, TType.I64, 'orderId', None, None, ), # 1
10248 
    (2, TType.I32, 'status', None, None, ), # 2
10249 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10250 
  )
10251 
 
483 rajveer 10252 
  def __init__(self, orderId=None, status=None, description=None,):
10253 
    self.orderId = orderId
10254 
    self.status = status
10255 
    self.description = description
94 ashish 10256 
 
10257 
  def read(self, iprot):
10258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10260 
      return
10261 
    iprot.readStructBegin()
10262 
    while True:
10263 
      (fname, ftype, fid) = iprot.readFieldBegin()
10264 
      if ftype == TType.STOP:
10265 
        break
10266 
      if fid == 1:
10267 
        if ftype == TType.I64:
483 rajveer 10268 
          self.orderId = iprot.readI64();
94 ashish 10269 
        else:
10270 
          iprot.skip(ftype)
10271 
      elif fid == 2:
483 rajveer 10272 
        if ftype == TType.I32:
10273 
          self.status = iprot.readI32();
94 ashish 10274 
        else:
10275 
          iprot.skip(ftype)
483 rajveer 10276 
      elif fid == 3:
10277 
        if ftype == TType.STRING:
10278 
          self.description = iprot.readString();
10279 
        else:
10280 
          iprot.skip(ftype)
94 ashish 10281 
      else:
10282 
        iprot.skip(ftype)
10283 
      iprot.readFieldEnd()
10284 
    iprot.readStructEnd()
10285 
 
10286 
  def write(self, oprot):
10287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10289 
      return
483 rajveer 10290 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10291 
    if self.orderId is not None:
483 rajveer 10292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10293 
      oprot.writeI64(self.orderId)
94 ashish 10294 
      oprot.writeFieldEnd()
3431 rajveer 10295 
    if self.status is not None:
483 rajveer 10296 
      oprot.writeFieldBegin('status', TType.I32, 2)
10297 
      oprot.writeI32(self.status)
94 ashish 10298 
      oprot.writeFieldEnd()
3431 rajveer 10299 
    if self.description is not None:
483 rajveer 10300 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10301 
      oprot.writeString(self.description)
10302 
      oprot.writeFieldEnd()
94 ashish 10303 
    oprot.writeFieldStop()
10304 
    oprot.writeStructEnd()
10305 
 
3431 rajveer 10306 
  def validate(self):
10307 
    return
10308 
 
10309 
 
94 ashish 10310 
  def __repr__(self):
10311 
    L = ['%s=%r' % (key, value)
10312 
      for key, value in self.__dict__.iteritems()]
10313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10314 
 
10315 
  def __eq__(self, other):
10316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10317 
 
10318 
  def __ne__(self, other):
10319 
    return not (self == other)
10320 
 
483 rajveer 10321 
class changeOrderStatus_result:
94 ashish 10322 
  """
10323 
  Attributes:
10324 
   - success
10325 
   - ex
10326 
  """
10327 
 
10328 
  thrift_spec = (
10329 
    (0, TType.BOOL, 'success', None, None, ), # 0
10330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10331 
  )
10332 
 
10333 
  def __init__(self, success=None, ex=None,):
10334 
    self.success = success
10335 
    self.ex = ex
10336 
 
10337 
  def read(self, iprot):
10338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10340 
      return
10341 
    iprot.readStructBegin()
10342 
    while True:
10343 
      (fname, ftype, fid) = iprot.readFieldBegin()
10344 
      if ftype == TType.STOP:
10345 
        break
10346 
      if fid == 0:
10347 
        if ftype == TType.BOOL:
10348 
          self.success = iprot.readBool();
10349 
        else:
10350 
          iprot.skip(ftype)
10351 
      elif fid == 1:
10352 
        if ftype == TType.STRUCT:
10353 
          self.ex = TransactionServiceException()
10354 
          self.ex.read(iprot)
10355 
        else:
10356 
          iprot.skip(ftype)
10357 
      else:
10358 
        iprot.skip(ftype)
10359 
      iprot.readFieldEnd()
10360 
    iprot.readStructEnd()
10361 
 
10362 
  def write(self, oprot):
10363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10365 
      return
483 rajveer 10366 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10367 
    if self.success is not None:
94 ashish 10368 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10369 
      oprot.writeBool(self.success)
10370 
      oprot.writeFieldEnd()
3431 rajveer 10371 
    if self.ex is not None:
94 ashish 10372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10373 
      self.ex.write(oprot)
10374 
      oprot.writeFieldEnd()
10375 
    oprot.writeFieldStop()
10376 
    oprot.writeStructEnd()
10377 
 
3431 rajveer 10378 
  def validate(self):
10379 
    return
10380 
 
10381 
 
94 ashish 10382 
  def __repr__(self):
10383 
    L = ['%s=%r' % (key, value)
10384 
      for key, value in self.__dict__.iteritems()]
10385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10386 
 
10387 
  def __eq__(self, other):
10388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10389 
 
10390 
  def __ne__(self, other):
10391 
    return not (self == other)
10392 
 
3064 chandransh 10393 
class getOrdersForTransaction_args:
494 rajveer 10394 
  """
10395 
  Attributes:
3064 chandransh 10396 
   - transactionId
10397 
   - customerId
494 rajveer 10398 
  """
10399 
 
10400 
  thrift_spec = (
10401 
    None, # 0
3064 chandransh 10402 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10403 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10404 
  )
10405 
 
3064 chandransh 10406 
  def __init__(self, transactionId=None, customerId=None,):
10407 
    self.transactionId = transactionId
10408 
    self.customerId = customerId
494 rajveer 10409 
 
10410 
  def read(self, iprot):
10411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10413 
      return
10414 
    iprot.readStructBegin()
10415 
    while True:
10416 
      (fname, ftype, fid) = iprot.readFieldBegin()
10417 
      if ftype == TType.STOP:
10418 
        break
10419 
      if fid == 1:
10420 
        if ftype == TType.I64:
3064 chandransh 10421 
          self.transactionId = iprot.readI64();
494 rajveer 10422 
        else:
10423 
          iprot.skip(ftype)
10424 
      elif fid == 2:
3064 chandransh 10425 
        if ftype == TType.I64:
10426 
          self.customerId = iprot.readI64();
494 rajveer 10427 
        else:
10428 
          iprot.skip(ftype)
10429 
      else:
10430 
        iprot.skip(ftype)
10431 
      iprot.readFieldEnd()
10432 
    iprot.readStructEnd()
10433 
 
10434 
  def write(self, oprot):
10435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10437 
      return
3064 chandransh 10438 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10439 
    if self.transactionId is not None:
3064 chandransh 10440 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10441 
      oprot.writeI64(self.transactionId)
494 rajveer 10442 
      oprot.writeFieldEnd()
3431 rajveer 10443 
    if self.customerId is not None:
3064 chandransh 10444 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10445 
      oprot.writeI64(self.customerId)
494 rajveer 10446 
      oprot.writeFieldEnd()
10447 
    oprot.writeFieldStop()
10448 
    oprot.writeStructEnd()
10449 
 
3431 rajveer 10450 
  def validate(self):
10451 
    return
10452 
 
10453 
 
494 rajveer 10454 
  def __repr__(self):
10455 
    L = ['%s=%r' % (key, value)
10456 
      for key, value in self.__dict__.iteritems()]
10457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10458 
 
10459 
  def __eq__(self, other):
10460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10461 
 
10462 
  def __ne__(self, other):
10463 
    return not (self == other)
10464 
 
3064 chandransh 10465 
class getOrdersForTransaction_result:
494 rajveer 10466 
  """
10467 
  Attributes:
10468 
   - success
10469 
   - ex
10470 
  """
10471 
 
10472 
  thrift_spec = (
3064 chandransh 10473 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10475 
  )
10476 
 
10477 
  def __init__(self, success=None, ex=None,):
10478 
    self.success = success
10479 
    self.ex = ex
10480 
 
10481 
  def read(self, iprot):
10482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10484 
      return
10485 
    iprot.readStructBegin()
10486 
    while True:
10487 
      (fname, ftype, fid) = iprot.readFieldBegin()
10488 
      if ftype == TType.STOP:
10489 
        break
10490 
      if fid == 0:
3064 chandransh 10491 
        if ftype == TType.LIST:
10492 
          self.success = []
6031 rajveer 10493 
          (_etype143, _size140) = iprot.readListBegin()
10494 
          for _i144 in xrange(_size140):
10495 
            _elem145 = Order()
10496 
            _elem145.read(iprot)
10497 
            self.success.append(_elem145)
3064 chandransh 10498 
          iprot.readListEnd()
494 rajveer 10499 
        else:
10500 
          iprot.skip(ftype)
10501 
      elif fid == 1:
10502 
        if ftype == TType.STRUCT:
10503 
          self.ex = TransactionServiceException()
10504 
          self.ex.read(iprot)
10505 
        else:
10506 
          iprot.skip(ftype)
10507 
      else:
10508 
        iprot.skip(ftype)
10509 
      iprot.readFieldEnd()
10510 
    iprot.readStructEnd()
10511 
 
10512 
  def write(self, oprot):
10513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10515 
      return
3064 chandransh 10516 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10517 
    if self.success is not None:
3064 chandransh 10518 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10519 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10520 
      for iter146 in self.success:
10521 
        iter146.write(oprot)
3064 chandransh 10522 
      oprot.writeListEnd()
494 rajveer 10523 
      oprot.writeFieldEnd()
3431 rajveer 10524 
    if self.ex is not None:
494 rajveer 10525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10526 
      self.ex.write(oprot)
10527 
      oprot.writeFieldEnd()
10528 
    oprot.writeFieldStop()
10529 
    oprot.writeStructEnd()
10530 
 
3431 rajveer 10531 
  def validate(self):
10532 
    return
10533 
 
10534 
 
494 rajveer 10535 
  def __repr__(self):
10536 
    L = ['%s=%r' % (key, value)
10537 
      for key, value in self.__dict__.iteritems()]
10538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10539 
 
10540 
  def __eq__(self, other):
10541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10542 
 
10543 
  def __ne__(self, other):
10544 
    return not (self == other)
10545 
 
3064 chandransh 10546 
class getOrdersForCustomer_args:
1149 chandransh 10547 
  """
10548 
  Attributes:
3064 chandransh 10549 
   - customerId
10550 
   - from_date
10551 
   - to_date
10552 
   - statuses
1149 chandransh 10553 
  """
10554 
 
10555 
  thrift_spec = (
10556 
    None, # 0
3064 chandransh 10557 
    (1, TType.I64, 'customerId', None, None, ), # 1
10558 
    (2, TType.I64, 'from_date', None, None, ), # 2
10559 
    (3, TType.I64, 'to_date', None, None, ), # 3
10560 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10561 
  )
10562 
 
3064 chandransh 10563 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10564 
    self.customerId = customerId
10565 
    self.from_date = from_date
10566 
    self.to_date = to_date
10567 
    self.statuses = statuses
1149 chandransh 10568 
 
10569 
  def read(self, iprot):
10570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10572 
      return
10573 
    iprot.readStructBegin()
10574 
    while True:
10575 
      (fname, ftype, fid) = iprot.readFieldBegin()
10576 
      if ftype == TType.STOP:
10577 
        break
10578 
      if fid == 1:
10579 
        if ftype == TType.I64:
3064 chandransh 10580 
          self.customerId = iprot.readI64();
1149 chandransh 10581 
        else:
10582 
          iprot.skip(ftype)
10583 
      elif fid == 2:
10584 
        if ftype == TType.I64:
3064 chandransh 10585 
          self.from_date = iprot.readI64();
1149 chandransh 10586 
        else:
10587 
          iprot.skip(ftype)
2783 chandransh 10588 
      elif fid == 3:
10589 
        if ftype == TType.I64:
3064 chandransh 10590 
          self.to_date = iprot.readI64();
2783 chandransh 10591 
        else:
10592 
          iprot.skip(ftype)
10593 
      elif fid == 4:
3064 chandransh 10594 
        if ftype == TType.LIST:
10595 
          self.statuses = []
6031 rajveer 10596 
          (_etype150, _size147) = iprot.readListBegin()
10597 
          for _i151 in xrange(_size147):
10598 
            _elem152 = iprot.readI32();
10599 
            self.statuses.append(_elem152)
3064 chandransh 10600 
          iprot.readListEnd()
2783 chandransh 10601 
        else:
10602 
          iprot.skip(ftype)
1149 chandransh 10603 
      else:
10604 
        iprot.skip(ftype)
10605 
      iprot.readFieldEnd()
10606 
    iprot.readStructEnd()
10607 
 
10608 
  def write(self, oprot):
10609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10611 
      return
3064 chandransh 10612 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10613 
    if self.customerId is not None:
3064 chandransh 10614 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10615 
      oprot.writeI64(self.customerId)
1149 chandransh 10616 
      oprot.writeFieldEnd()
3431 rajveer 10617 
    if self.from_date is not None:
3064 chandransh 10618 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10619 
      oprot.writeI64(self.from_date)
1149 chandransh 10620 
      oprot.writeFieldEnd()
3431 rajveer 10621 
    if self.to_date is not None:
3064 chandransh 10622 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10623 
      oprot.writeI64(self.to_date)
2783 chandransh 10624 
      oprot.writeFieldEnd()
3431 rajveer 10625 
    if self.statuses is not None:
3064 chandransh 10626 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10627 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 10628 
      for iter153 in self.statuses:
10629 
        oprot.writeI32(iter153)
3064 chandransh 10630 
      oprot.writeListEnd()
2783 chandransh 10631 
      oprot.writeFieldEnd()
1149 chandransh 10632 
    oprot.writeFieldStop()
10633 
    oprot.writeStructEnd()
10634 
 
3431 rajveer 10635 
  def validate(self):
10636 
    return
10637 
 
10638 
 
1149 chandransh 10639 
  def __repr__(self):
10640 
    L = ['%s=%r' % (key, value)
10641 
      for key, value in self.__dict__.iteritems()]
10642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10643 
 
10644 
  def __eq__(self, other):
10645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10646 
 
10647 
  def __ne__(self, other):
10648 
    return not (self == other)
10649 
 
3064 chandransh 10650 
class getOrdersForCustomer_result:
1149 chandransh 10651 
  """
10652 
  Attributes:
10653 
   - success
10654 
   - ex
10655 
  """
10656 
 
10657 
  thrift_spec = (
3064 chandransh 10658 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10659 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10660 
  )
10661 
 
10662 
  def __init__(self, success=None, ex=None,):
10663 
    self.success = success
10664 
    self.ex = ex
10665 
 
10666 
  def read(self, iprot):
10667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10669 
      return
10670 
    iprot.readStructBegin()
10671 
    while True:
10672 
      (fname, ftype, fid) = iprot.readFieldBegin()
10673 
      if ftype == TType.STOP:
10674 
        break
10675 
      if fid == 0:
3064 chandransh 10676 
        if ftype == TType.LIST:
10677 
          self.success = []
6031 rajveer 10678 
          (_etype157, _size154) = iprot.readListBegin()
10679 
          for _i158 in xrange(_size154):
10680 
            _elem159 = Order()
10681 
            _elem159.read(iprot)
10682 
            self.success.append(_elem159)
3064 chandransh 10683 
          iprot.readListEnd()
1149 chandransh 10684 
        else:
10685 
          iprot.skip(ftype)
10686 
      elif fid == 1:
10687 
        if ftype == TType.STRUCT:
10688 
          self.ex = TransactionServiceException()
10689 
          self.ex.read(iprot)
10690 
        else:
10691 
          iprot.skip(ftype)
10692 
      else:
10693 
        iprot.skip(ftype)
10694 
      iprot.readFieldEnd()
10695 
    iprot.readStructEnd()
10696 
 
10697 
  def write(self, oprot):
10698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10700 
      return
3064 chandransh 10701 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10702 
    if self.success is not None:
3064 chandransh 10703 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10704 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10705 
      for iter160 in self.success:
10706 
        iter160.write(oprot)
3064 chandransh 10707 
      oprot.writeListEnd()
1149 chandransh 10708 
      oprot.writeFieldEnd()
3431 rajveer 10709 
    if self.ex is not None:
1149 chandransh 10710 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10711 
      self.ex.write(oprot)
10712 
      oprot.writeFieldEnd()
10713 
    oprot.writeFieldStop()
10714 
    oprot.writeStructEnd()
10715 
 
3431 rajveer 10716 
  def validate(self):
10717 
    return
10718 
 
10719 
 
1149 chandransh 10720 
  def __repr__(self):
10721 
    L = ['%s=%r' % (key, value)
10722 
      for key, value in self.__dict__.iteritems()]
10723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10724 
 
10725 
  def __eq__(self, other):
10726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10727 
 
10728 
  def __ne__(self, other):
10729 
    return not (self == other)
10730 
 
3064 chandransh 10731 
class createOrder_args:
921 rajveer 10732 
  """
10733 
  Attributes:
3064 chandransh 10734 
   - order
921 rajveer 10735 
  """
10736 
 
10737 
  thrift_spec = (
10738 
    None, # 0
3064 chandransh 10739 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10740 
  )
10741 
 
3064 chandransh 10742 
  def __init__(self, order=None,):
10743 
    self.order = order
921 rajveer 10744 
 
10745 
  def read(self, iprot):
10746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10748 
      return
10749 
    iprot.readStructBegin()
10750 
    while True:
10751 
      (fname, ftype, fid) = iprot.readFieldBegin()
10752 
      if ftype == TType.STOP:
10753 
        break
10754 
      if fid == 1:
3064 chandransh 10755 
        if ftype == TType.STRUCT:
10756 
          self.order = Order()
10757 
          self.order.read(iprot)
921 rajveer 10758 
        else:
10759 
          iprot.skip(ftype)
10760 
      else:
10761 
        iprot.skip(ftype)
10762 
      iprot.readFieldEnd()
10763 
    iprot.readStructEnd()
10764 
 
10765 
  def write(self, oprot):
10766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10768 
      return
3064 chandransh 10769 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10770 
    if self.order is not None:
3064 chandransh 10771 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10772 
      self.order.write(oprot)
921 rajveer 10773 
      oprot.writeFieldEnd()
10774 
    oprot.writeFieldStop()
10775 
    oprot.writeStructEnd()
10776 
 
3431 rajveer 10777 
  def validate(self):
10778 
    return
10779 
 
10780 
 
921 rajveer 10781 
  def __repr__(self):
10782 
    L = ['%s=%r' % (key, value)
10783 
      for key, value in self.__dict__.iteritems()]
10784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10785 
 
10786 
  def __eq__(self, other):
10787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10788 
 
10789 
  def __ne__(self, other):
10790 
    return not (self == other)
10791 
 
3064 chandransh 10792 
class createOrder_result:
921 rajveer 10793 
  """
10794 
  Attributes:
10795 
   - success
10796 
   - ex
10797 
  """
10798 
 
10799 
  thrift_spec = (
3064 chandransh 10800 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10801 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10802 
  )
10803 
 
10804 
  def __init__(self, success=None, ex=None,):
10805 
    self.success = success
10806 
    self.ex = ex
10807 
 
10808 
  def read(self, iprot):
10809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10811 
      return
10812 
    iprot.readStructBegin()
10813 
    while True:
10814 
      (fname, ftype, fid) = iprot.readFieldBegin()
10815 
      if ftype == TType.STOP:
10816 
        break
10817 
      if fid == 0:
3064 chandransh 10818 
        if ftype == TType.I64:
10819 
          self.success = iprot.readI64();
921 rajveer 10820 
        else:
10821 
          iprot.skip(ftype)
10822 
      elif fid == 1:
10823 
        if ftype == TType.STRUCT:
10824 
          self.ex = TransactionServiceException()
10825 
          self.ex.read(iprot)
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('createOrder_result')
3431 rajveer 10838 
    if self.success is not None:
3064 chandransh 10839 
      oprot.writeFieldBegin('success', TType.I64, 0)
10840 
      oprot.writeI64(self.success)
921 rajveer 10841 
      oprot.writeFieldEnd()
3431 rajveer 10842 
    if self.ex is not None:
921 rajveer 10843 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10844 
      self.ex.write(oprot)
10845 
      oprot.writeFieldEnd()
10846 
    oprot.writeFieldStop()
10847 
    oprot.writeStructEnd()
10848 
 
3431 rajveer 10849 
  def validate(self):
10850 
    return
10851 
 
10852 
 
921 rajveer 10853 
  def __repr__(self):
10854 
    L = ['%s=%r' % (key, value)
10855 
      for key, value in self.__dict__.iteritems()]
10856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10857 
 
10858 
  def __eq__(self, other):
10859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10860 
 
10861 
  def __ne__(self, other):
10862 
    return not (self == other)
10863 
 
3064 chandransh 10864 
class getOrder_args:
921 rajveer 10865 
  """
10866 
  Attributes:
3064 chandransh 10867 
   - id
921 rajveer 10868 
  """
10869 
 
10870 
  thrift_spec = (
10871 
    None, # 0
3064 chandransh 10872 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10873 
  )
10874 
 
3064 chandransh 10875 
  def __init__(self, id=None,):
10876 
    self.id = id
921 rajveer 10877 
 
10878 
  def read(self, iprot):
10879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10881 
      return
10882 
    iprot.readStructBegin()
10883 
    while True:
10884 
      (fname, ftype, fid) = iprot.readFieldBegin()
10885 
      if ftype == TType.STOP:
10886 
        break
10887 
      if fid == 1:
10888 
        if ftype == TType.I64:
3064 chandransh 10889 
          self.id = iprot.readI64();
921 rajveer 10890 
        else:
10891 
          iprot.skip(ftype)
10892 
      else:
10893 
        iprot.skip(ftype)
10894 
      iprot.readFieldEnd()
10895 
    iprot.readStructEnd()
10896 
 
10897 
  def write(self, oprot):
10898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10900 
      return
3064 chandransh 10901 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10902 
    if self.id is not None:
3064 chandransh 10903 
      oprot.writeFieldBegin('id', TType.I64, 1)
10904 
      oprot.writeI64(self.id)
921 rajveer 10905 
      oprot.writeFieldEnd()
10906 
    oprot.writeFieldStop()
10907 
    oprot.writeStructEnd()
10908 
 
3431 rajveer 10909 
  def validate(self):
10910 
    return
10911 
 
10912 
 
921 rajveer 10913 
  def __repr__(self):
10914 
    L = ['%s=%r' % (key, value)
10915 
      for key, value in self.__dict__.iteritems()]
10916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10917 
 
10918 
  def __eq__(self, other):
10919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10920 
 
10921 
  def __ne__(self, other):
10922 
    return not (self == other)
10923 
 
3064 chandransh 10924 
class getOrder_result:
921 rajveer 10925 
  """
10926 
  Attributes:
10927 
   - success
10928 
   - ex
10929 
  """
10930 
 
10931 
  thrift_spec = (
3064 chandransh 10932 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10933 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10934 
  )
10935 
 
10936 
  def __init__(self, success=None, ex=None,):
10937 
    self.success = success
10938 
    self.ex = ex
10939 
 
10940 
  def read(self, iprot):
10941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10943 
      return
10944 
    iprot.readStructBegin()
10945 
    while True:
10946 
      (fname, ftype, fid) = iprot.readFieldBegin()
10947 
      if ftype == TType.STOP:
10948 
        break
10949 
      if fid == 0:
3064 chandransh 10950 
        if ftype == TType.STRUCT:
10951 
          self.success = Order()
10952 
          self.success.read(iprot)
921 rajveer 10953 
        else:
10954 
          iprot.skip(ftype)
10955 
      elif fid == 1:
10956 
        if ftype == TType.STRUCT:
10957 
          self.ex = TransactionServiceException()
10958 
          self.ex.read(iprot)
10959 
        else:
10960 
          iprot.skip(ftype)
10961 
      else:
10962 
        iprot.skip(ftype)
10963 
      iprot.readFieldEnd()
10964 
    iprot.readStructEnd()
10965 
 
10966 
  def write(self, oprot):
10967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10969 
      return
3064 chandransh 10970 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10971 
    if self.success is not None:
3064 chandransh 10972 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10973 
      self.success.write(oprot)
921 rajveer 10974 
      oprot.writeFieldEnd()
3431 rajveer 10975 
    if self.ex is not None:
921 rajveer 10976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10977 
      self.ex.write(oprot)
10978 
      oprot.writeFieldEnd()
10979 
    oprot.writeFieldStop()
10980 
    oprot.writeStructEnd()
10981 
 
3431 rajveer 10982 
  def validate(self):
10983 
    return
10984 
 
10985 
 
921 rajveer 10986 
  def __repr__(self):
10987 
    L = ['%s=%r' % (key, value)
10988 
      for key, value in self.__dict__.iteritems()]
10989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10990 
 
10991 
  def __eq__(self, other):
10992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10993 
 
10994 
  def __ne__(self, other):
10995 
    return not (self == other)
10996 
 
3064 chandransh 10997 
class getLineItemsForOrder_args:
94 ashish 10998 
  """
10999 
  Attributes:
3064 chandransh 11000 
   - orderId
94 ashish 11001 
  """
11002 
 
11003 
  thrift_spec = (
11004 
    None, # 0
3064 chandransh 11005 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11006 
  )
11007 
 
3064 chandransh 11008 
  def __init__(self, orderId=None,):
11009 
    self.orderId = orderId
94 ashish 11010 
 
11011 
  def read(self, iprot):
11012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11014 
      return
11015 
    iprot.readStructBegin()
11016 
    while True:
11017 
      (fname, ftype, fid) = iprot.readFieldBegin()
11018 
      if ftype == TType.STOP:
11019 
        break
11020 
      if fid == 1:
11021 
        if ftype == TType.I64:
3064 chandransh 11022 
          self.orderId = iprot.readI64();
94 ashish 11023 
        else:
11024 
          iprot.skip(ftype)
11025 
      else:
11026 
        iprot.skip(ftype)
11027 
      iprot.readFieldEnd()
11028 
    iprot.readStructEnd()
11029 
 
11030 
  def write(self, oprot):
11031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11033 
      return
3064 chandransh 11034 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11035 
    if self.orderId is not None:
3064 chandransh 11036 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11037 
      oprot.writeI64(self.orderId)
94 ashish 11038 
      oprot.writeFieldEnd()
11039 
    oprot.writeFieldStop()
11040 
    oprot.writeStructEnd()
11041 
 
3431 rajveer 11042 
  def validate(self):
11043 
    return
11044 
 
11045 
 
94 ashish 11046 
  def __repr__(self):
11047 
    L = ['%s=%r' % (key, value)
11048 
      for key, value in self.__dict__.iteritems()]
11049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11050 
 
11051 
  def __eq__(self, other):
11052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11053 
 
11054 
  def __ne__(self, other):
11055 
    return not (self == other)
11056 
 
3064 chandransh 11057 
class getLineItemsForOrder_result:
94 ashish 11058 
  """
11059 
  Attributes:
11060 
   - success
11061 
   - ex
11062 
  """
11063 
 
11064 
  thrift_spec = (
3064 chandransh 11065 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11067 
  )
11068 
 
11069 
  def __init__(self, success=None, ex=None,):
11070 
    self.success = success
11071 
    self.ex = ex
11072 
 
11073 
  def read(self, iprot):
11074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11076 
      return
11077 
    iprot.readStructBegin()
11078 
    while True:
11079 
      (fname, ftype, fid) = iprot.readFieldBegin()
11080 
      if ftype == TType.STOP:
11081 
        break
11082 
      if fid == 0:
483 rajveer 11083 
        if ftype == TType.LIST:
11084 
          self.success = []
6031 rajveer 11085 
          (_etype164, _size161) = iprot.readListBegin()
11086 
          for _i165 in xrange(_size161):
11087 
            _elem166 = LineItem()
11088 
            _elem166.read(iprot)
11089 
            self.success.append(_elem166)
483 rajveer 11090 
          iprot.readListEnd()
94 ashish 11091 
        else:
11092 
          iprot.skip(ftype)
11093 
      elif fid == 1:
11094 
        if ftype == TType.STRUCT:
11095 
          self.ex = TransactionServiceException()
11096 
          self.ex.read(iprot)
11097 
        else:
11098 
          iprot.skip(ftype)
11099 
      else:
11100 
        iprot.skip(ftype)
11101 
      iprot.readFieldEnd()
11102 
    iprot.readStructEnd()
11103 
 
11104 
  def write(self, oprot):
11105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11107 
      return
3064 chandransh 11108 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11109 
    if self.success is not None:
483 rajveer 11110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11111 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11112 
      for iter167 in self.success:
11113 
        iter167.write(oprot)
483 rajveer 11114 
      oprot.writeListEnd()
94 ashish 11115 
      oprot.writeFieldEnd()
3431 rajveer 11116 
    if self.ex is not None:
94 ashish 11117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11118 
      self.ex.write(oprot)
11119 
      oprot.writeFieldEnd()
11120 
    oprot.writeFieldStop()
11121 
    oprot.writeStructEnd()
11122 
 
3431 rajveer 11123 
  def validate(self):
11124 
    return
11125 
 
11126 
 
94 ashish 11127 
  def __repr__(self):
11128 
    L = ['%s=%r' % (key, value)
11129 
      for key, value in self.__dict__.iteritems()]
11130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11131 
 
11132 
  def __eq__(self, other):
11133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11134 
 
11135 
  def __ne__(self, other):
11136 
    return not (self == other)
11137 
 
4999 phani.kuma 11138 
class getOrderList_args:
11139 
  """
11140 
  Attributes:
11141 
   - order_ids
11142 
  """
11143 
 
11144 
  thrift_spec = (
11145 
    None, # 0
11146 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11147 
  )
11148 
 
11149 
  def __init__(self, order_ids=None,):
11150 
    self.order_ids = order_ids
11151 
 
11152 
  def read(self, iprot):
11153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11155 
      return
11156 
    iprot.readStructBegin()
11157 
    while True:
11158 
      (fname, ftype, fid) = iprot.readFieldBegin()
11159 
      if ftype == TType.STOP:
11160 
        break
11161 
      if fid == 1:
11162 
        if ftype == TType.LIST:
11163 
          self.order_ids = []
6031 rajveer 11164 
          (_etype171, _size168) = iprot.readListBegin()
11165 
          for _i172 in xrange(_size168):
11166 
            _elem173 = iprot.readI64();
11167 
            self.order_ids.append(_elem173)
4999 phani.kuma 11168 
          iprot.readListEnd()
11169 
        else:
11170 
          iprot.skip(ftype)
11171 
      else:
11172 
        iprot.skip(ftype)
11173 
      iprot.readFieldEnd()
11174 
    iprot.readStructEnd()
11175 
 
11176 
  def write(self, oprot):
11177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11179 
      return
11180 
    oprot.writeStructBegin('getOrderList_args')
11181 
    if self.order_ids is not None:
11182 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11183 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11184 
      for iter174 in self.order_ids:
11185 
        oprot.writeI64(iter174)
4999 phani.kuma 11186 
      oprot.writeListEnd()
11187 
      oprot.writeFieldEnd()
11188 
    oprot.writeFieldStop()
11189 
    oprot.writeStructEnd()
11190 
 
11191 
  def validate(self):
11192 
    return
11193 
 
11194 
 
11195 
  def __repr__(self):
11196 
    L = ['%s=%r' % (key, value)
11197 
      for key, value in self.__dict__.iteritems()]
11198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11199 
 
11200 
  def __eq__(self, other):
11201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11202 
 
11203 
  def __ne__(self, other):
11204 
    return not (self == other)
11205 
 
11206 
class getOrderList_result:
11207 
  """
11208 
  Attributes:
11209 
   - success
11210 
  """
11211 
 
11212 
  thrift_spec = (
11213 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11214 
  )
11215 
 
11216 
  def __init__(self, success=None,):
11217 
    self.success = success
11218 
 
11219 
  def read(self, iprot):
11220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11222 
      return
11223 
    iprot.readStructBegin()
11224 
    while True:
11225 
      (fname, ftype, fid) = iprot.readFieldBegin()
11226 
      if ftype == TType.STOP:
11227 
        break
11228 
      if fid == 0:
11229 
        if ftype == TType.LIST:
11230 
          self.success = []
6031 rajveer 11231 
          (_etype178, _size175) = iprot.readListBegin()
11232 
          for _i179 in xrange(_size175):
11233 
            _elem180 = Order()
11234 
            _elem180.read(iprot)
11235 
            self.success.append(_elem180)
4999 phani.kuma 11236 
          iprot.readListEnd()
11237 
        else:
11238 
          iprot.skip(ftype)
11239 
      else:
11240 
        iprot.skip(ftype)
11241 
      iprot.readFieldEnd()
11242 
    iprot.readStructEnd()
11243 
 
11244 
  def write(self, oprot):
11245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11247 
      return
11248 
    oprot.writeStructBegin('getOrderList_result')
11249 
    if self.success is not None:
11250 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11251 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11252 
      for iter181 in self.success:
11253 
        iter181.write(oprot)
4999 phani.kuma 11254 
      oprot.writeListEnd()
11255 
      oprot.writeFieldEnd()
11256 
    oprot.writeFieldStop()
11257 
    oprot.writeStructEnd()
11258 
 
11259 
  def validate(self):
11260 
    return
11261 
 
11262 
 
11263 
  def __repr__(self):
11264 
    L = ['%s=%r' % (key, value)
11265 
      for key, value in self.__dict__.iteritems()]
11266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11267 
 
11268 
  def __eq__(self, other):
11269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11270 
 
11271 
  def __ne__(self, other):
11272 
    return not (self == other)
11273 
 
5386 phani.kuma 11274 
class getOrderListForVendor_args:
11275 
  """
11276 
  Attributes:
11277 
   - order_ids
11278 
   - vendorId
11279 
  """
11280 
 
11281 
  thrift_spec = (
11282 
    None, # 0
11283 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11284 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11285 
  )
11286 
 
11287 
  def __init__(self, order_ids=None, vendorId=None,):
11288 
    self.order_ids = order_ids
11289 
    self.vendorId = vendorId
11290 
 
11291 
  def read(self, iprot):
11292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11294 
      return
11295 
    iprot.readStructBegin()
11296 
    while True:
11297 
      (fname, ftype, fid) = iprot.readFieldBegin()
11298 
      if ftype == TType.STOP:
11299 
        break
11300 
      if fid == 1:
11301 
        if ftype == TType.LIST:
11302 
          self.order_ids = []
6031 rajveer 11303 
          (_etype185, _size182) = iprot.readListBegin()
11304 
          for _i186 in xrange(_size182):
11305 
            _elem187 = iprot.readI64();
11306 
            self.order_ids.append(_elem187)
5386 phani.kuma 11307 
          iprot.readListEnd()
11308 
        else:
11309 
          iprot.skip(ftype)
11310 
      elif fid == 2:
11311 
        if ftype == TType.I64:
11312 
          self.vendorId = iprot.readI64();
11313 
        else:
11314 
          iprot.skip(ftype)
11315 
      else:
11316 
        iprot.skip(ftype)
11317 
      iprot.readFieldEnd()
11318 
    iprot.readStructEnd()
11319 
 
11320 
  def write(self, oprot):
11321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11323 
      return
11324 
    oprot.writeStructBegin('getOrderListForVendor_args')
11325 
    if self.order_ids is not None:
11326 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11327 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11328 
      for iter188 in self.order_ids:
11329 
        oprot.writeI64(iter188)
5386 phani.kuma 11330 
      oprot.writeListEnd()
11331 
      oprot.writeFieldEnd()
11332 
    if self.vendorId is not None:
11333 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11334 
      oprot.writeI64(self.vendorId)
11335 
      oprot.writeFieldEnd()
11336 
    oprot.writeFieldStop()
11337 
    oprot.writeStructEnd()
11338 
 
11339 
  def validate(self):
11340 
    return
11341 
 
11342 
 
11343 
  def __repr__(self):
11344 
    L = ['%s=%r' % (key, value)
11345 
      for key, value in self.__dict__.iteritems()]
11346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11347 
 
11348 
  def __eq__(self, other):
11349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11350 
 
11351 
  def __ne__(self, other):
11352 
    return not (self == other)
11353 
 
11354 
class getOrderListForVendor_result:
11355 
  """
11356 
  Attributes:
11357 
   - success
11358 
  """
11359 
 
11360 
  thrift_spec = (
11361 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11362 
  )
11363 
 
11364 
  def __init__(self, success=None,):
11365 
    self.success = success
11366 
 
11367 
  def read(self, iprot):
11368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11370 
      return
11371 
    iprot.readStructBegin()
11372 
    while True:
11373 
      (fname, ftype, fid) = iprot.readFieldBegin()
11374 
      if ftype == TType.STOP:
11375 
        break
11376 
      if fid == 0:
11377 
        if ftype == TType.LIST:
11378 
          self.success = []
6031 rajveer 11379 
          (_etype192, _size189) = iprot.readListBegin()
11380 
          for _i193 in xrange(_size189):
11381 
            _elem194 = Order()
11382 
            _elem194.read(iprot)
11383 
            self.success.append(_elem194)
5386 phani.kuma 11384 
          iprot.readListEnd()
11385 
        else:
11386 
          iprot.skip(ftype)
11387 
      else:
11388 
        iprot.skip(ftype)
11389 
      iprot.readFieldEnd()
11390 
    iprot.readStructEnd()
11391 
 
11392 
  def write(self, oprot):
11393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11395 
      return
11396 
    oprot.writeStructBegin('getOrderListForVendor_result')
11397 
    if self.success is not None:
11398 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11399 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11400 
      for iter195 in self.success:
11401 
        iter195.write(oprot)
5386 phani.kuma 11402 
      oprot.writeListEnd()
11403 
      oprot.writeFieldEnd()
11404 
    oprot.writeFieldStop()
11405 
    oprot.writeStructEnd()
11406 
 
11407 
  def validate(self):
11408 
    return
11409 
 
11410 
 
11411 
  def __repr__(self):
11412 
    L = ['%s=%r' % (key, value)
11413 
      for key, value in self.__dict__.iteritems()]
11414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11415 
 
11416 
  def __eq__(self, other):
11417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11418 
 
11419 
  def __ne__(self, other):
11420 
    return not (self == other)
11421 
 
3064 chandransh 11422 
class getOrderForCustomer_args:
94 ashish 11423 
  """
11424 
  Attributes:
3064 chandransh 11425 
   - orderId
483 rajveer 11426 
   - customerId
94 ashish 11427 
  """
11428 
 
11429 
  thrift_spec = (
11430 
    None, # 0
3064 chandransh 11431 
    (1, TType.I64, 'orderId', None, None, ), # 1
11432 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11433 
  )
11434 
 
3064 chandransh 11435 
  def __init__(self, orderId=None, customerId=None,):
11436 
    self.orderId = orderId
483 rajveer 11437 
    self.customerId = customerId
94 ashish 11438 
 
11439 
  def read(self, iprot):
11440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11442 
      return
11443 
    iprot.readStructBegin()
11444 
    while True:
11445 
      (fname, ftype, fid) = iprot.readFieldBegin()
11446 
      if ftype == TType.STOP:
11447 
        break
11448 
      if fid == 1:
11449 
        if ftype == TType.I64:
3064 chandransh 11450 
          self.orderId = iprot.readI64();
94 ashish 11451 
        else:
11452 
          iprot.skip(ftype)
11453 
      elif fid == 2:
11454 
        if ftype == TType.I64:
3064 chandransh 11455 
          self.customerId = iprot.readI64();
94 ashish 11456 
        else:
11457 
          iprot.skip(ftype)
11458 
      else:
11459 
        iprot.skip(ftype)
11460 
      iprot.readFieldEnd()
11461 
    iprot.readStructEnd()
11462 
 
11463 
  def write(self, oprot):
11464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11466 
      return
3064 chandransh 11467 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11468 
    if self.orderId is not None:
3064 chandransh 11469 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11470 
      oprot.writeI64(self.orderId)
11471 
      oprot.writeFieldEnd()
3431 rajveer 11472 
    if self.customerId is not None:
3064 chandransh 11473 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11474 
      oprot.writeI64(self.customerId)
94 ashish 11475 
      oprot.writeFieldEnd()
11476 
    oprot.writeFieldStop()
11477 
    oprot.writeStructEnd()
11478 
 
3431 rajveer 11479 
  def validate(self):
11480 
    return
11481 
 
11482 
 
94 ashish 11483 
  def __repr__(self):
11484 
    L = ['%s=%r' % (key, value)
11485 
      for key, value in self.__dict__.iteritems()]
11486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11487 
 
11488 
  def __eq__(self, other):
11489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11490 
 
11491 
  def __ne__(self, other):
11492 
    return not (self == other)
11493 
 
3064 chandransh 11494 
class getOrderForCustomer_result:
94 ashish 11495 
  """
11496 
  Attributes:
11497 
   - success
11498 
   - ex
11499 
  """
11500 
 
11501 
  thrift_spec = (
3064 chandransh 11502 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11503 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11504 
  )
11505 
 
11506 
  def __init__(self, success=None, ex=None,):
11507 
    self.success = success
11508 
    self.ex = ex
11509 
 
11510 
  def read(self, iprot):
11511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11513 
      return
11514 
    iprot.readStructBegin()
11515 
    while True:
11516 
      (fname, ftype, fid) = iprot.readFieldBegin()
11517 
      if ftype == TType.STOP:
11518 
        break
11519 
      if fid == 0:
3064 chandransh 11520 
        if ftype == TType.STRUCT:
11521 
          self.success = Order()
11522 
          self.success.read(iprot)
94 ashish 11523 
        else:
11524 
          iprot.skip(ftype)
11525 
      elif fid == 1:
11526 
        if ftype == TType.STRUCT:
11527 
          self.ex = TransactionServiceException()
11528 
          self.ex.read(iprot)
11529 
        else:
11530 
          iprot.skip(ftype)
11531 
      else:
11532 
        iprot.skip(ftype)
11533 
      iprot.readFieldEnd()
11534 
    iprot.readStructEnd()
11535 
 
11536 
  def write(self, oprot):
11537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11539 
      return
3064 chandransh 11540 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11541 
    if self.success is not None:
3064 chandransh 11542 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11543 
      self.success.write(oprot)
94 ashish 11544 
      oprot.writeFieldEnd()
3431 rajveer 11545 
    if self.ex is not None:
94 ashish 11546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11547 
      self.ex.write(oprot)
11548 
      oprot.writeFieldEnd()
11549 
    oprot.writeFieldStop()
11550 
    oprot.writeStructEnd()
11551 
 
3431 rajveer 11552 
  def validate(self):
11553 
    return
11554 
 
11555 
 
94 ashish 11556 
  def __repr__(self):
11557 
    L = ['%s=%r' % (key, value)
11558 
      for key, value in self.__dict__.iteritems()]
11559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11560 
 
11561 
  def __eq__(self, other):
11562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11563 
 
11564 
  def __ne__(self, other):
11565 
    return not (self == other)
11566 
 
3064 chandransh 11567 
class getAlerts_args:
94 ashish 11568 
  """
11569 
  Attributes:
4394 rajveer 11570 
   - type
4444 rajveer 11571 
   - warehouseId
4394 rajveer 11572 
   - status
11573 
   - timestamp
94 ashish 11574 
  """
11575 
 
11576 
  thrift_spec = (
11577 
    None, # 0
4394 rajveer 11578 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11579 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11580 
    (3, TType.I64, 'status', None, None, ), # 3
11581 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11582 
  )
11583 
 
4444 rajveer 11584 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11585 
    self.type = type
4444 rajveer 11586 
    self.warehouseId = warehouseId
4394 rajveer 11587 
    self.status = status
11588 
    self.timestamp = timestamp
94 ashish 11589 
 
11590 
  def read(self, iprot):
11591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11593 
      return
11594 
    iprot.readStructBegin()
11595 
    while True:
11596 
      (fname, ftype, fid) = iprot.readFieldBegin()
11597 
      if ftype == TType.STOP:
11598 
        break
11599 
      if fid == 1:
3064 chandransh 11600 
        if ftype == TType.I64:
4394 rajveer 11601 
          self.type = iprot.readI64();
94 ashish 11602 
        else:
11603 
          iprot.skip(ftype)
3064 chandransh 11604 
      elif fid == 2:
4394 rajveer 11605 
        if ftype == TType.I64:
4444 rajveer 11606 
          self.warehouseId = iprot.readI64();
3064 chandransh 11607 
        else:
11608 
          iprot.skip(ftype)
4394 rajveer 11609 
      elif fid == 3:
11610 
        if ftype == TType.I64:
4444 rajveer 11611 
          self.status = iprot.readI64();
11612 
        else:
11613 
          iprot.skip(ftype)
11614 
      elif fid == 4:
11615 
        if ftype == TType.I64:
4394 rajveer 11616 
          self.timestamp = iprot.readI64();
11617 
        else:
11618 
          iprot.skip(ftype)
94 ashish 11619 
      else:
11620 
        iprot.skip(ftype)
11621 
      iprot.readFieldEnd()
11622 
    iprot.readStructEnd()
11623 
 
11624 
  def write(self, oprot):
11625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11627 
      return
3064 chandransh 11628 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11629 
    if self.type is not None:
11630 
      oprot.writeFieldBegin('type', TType.I64, 1)
11631 
      oprot.writeI64(self.type)
94 ashish 11632 
      oprot.writeFieldEnd()
4444 rajveer 11633 
    if self.warehouseId is not None:
11634 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11635 
      oprot.writeI64(self.warehouseId)
11636 
      oprot.writeFieldEnd()
4394 rajveer 11637 
    if self.status is not None:
4444 rajveer 11638 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11639 
      oprot.writeI64(self.status)
3064 chandransh 11640 
      oprot.writeFieldEnd()
4394 rajveer 11641 
    if self.timestamp is not None:
4444 rajveer 11642 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11643 
      oprot.writeI64(self.timestamp)
11644 
      oprot.writeFieldEnd()
94 ashish 11645 
    oprot.writeFieldStop()
11646 
    oprot.writeStructEnd()
11647 
 
3431 rajveer 11648 
  def validate(self):
11649 
    return
11650 
 
11651 
 
94 ashish 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 getAlerts_result:
94 ashish 11664 
  """
11665 
  Attributes:
11666 
   - success
11667 
  """
11668 
 
11669 
  thrift_spec = (
3064 chandransh 11670 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11671 
  )
11672 
 
3064 chandransh 11673 
  def __init__(self, success=None,):
94 ashish 11674 
    self.success = success
11675 
 
11676 
  def read(self, iprot):
11677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11679 
      return
11680 
    iprot.readStructBegin()
11681 
    while True:
11682 
      (fname, ftype, fid) = iprot.readFieldBegin()
11683 
      if ftype == TType.STOP:
11684 
        break
11685 
      if fid == 0:
3064 chandransh 11686 
        if ftype == TType.LIST:
11687 
          self.success = []
6031 rajveer 11688 
          (_etype199, _size196) = iprot.readListBegin()
11689 
          for _i200 in xrange(_size196):
11690 
            _elem201 = Alert()
11691 
            _elem201.read(iprot)
11692 
            self.success.append(_elem201)
3064 chandransh 11693 
          iprot.readListEnd()
94 ashish 11694 
        else:
11695 
          iprot.skip(ftype)
11696 
      else:
11697 
        iprot.skip(ftype)
11698 
      iprot.readFieldEnd()
11699 
    iprot.readStructEnd()
11700 
 
11701 
  def write(self, oprot):
11702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11704 
      return
3064 chandransh 11705 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11706 
    if self.success is not None:
3064 chandransh 11707 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11708 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11709 
      for iter202 in self.success:
11710 
        iter202.write(oprot)
3064 chandransh 11711 
      oprot.writeListEnd()
94 ashish 11712 
      oprot.writeFieldEnd()
11713 
    oprot.writeFieldStop()
11714 
    oprot.writeStructEnd()
11715 
 
3431 rajveer 11716 
  def validate(self):
11717 
    return
11718 
 
11719 
 
94 ashish 11720 
  def __repr__(self):
11721 
    L = ['%s=%r' % (key, value)
11722 
      for key, value in self.__dict__.iteritems()]
11723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11724 
 
11725 
  def __eq__(self, other):
11726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11727 
 
11728 
  def __ne__(self, other):
11729 
    return not (self == other)
11730 
 
4394 rajveer 11731 
class addAlert_args:
94 ashish 11732 
  """
11733 
  Attributes:
3064 chandransh 11734 
   - type
4444 rajveer 11735 
   - warehouseId
4394 rajveer 11736 
   - description
94 ashish 11737 
  """
11738 
 
11739 
  thrift_spec = (
11740 
    None, # 0
4394 rajveer 11741 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11742 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11743 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11744 
  )
11745 
 
4444 rajveer 11746 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11747 
    self.type = type
4444 rajveer 11748 
    self.warehouseId = warehouseId
4394 rajveer 11749 
    self.description = description
94 ashish 11750 
 
11751 
  def read(self, iprot):
11752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11754 
      return
11755 
    iprot.readStructBegin()
11756 
    while True:
11757 
      (fname, ftype, fid) = iprot.readFieldBegin()
11758 
      if ftype == TType.STOP:
11759 
        break
11760 
      if fid == 1:
11761 
        if ftype == TType.I64:
4394 rajveer 11762 
          self.type = iprot.readI64();
94 ashish 11763 
        else:
11764 
          iprot.skip(ftype)
3064 chandransh 11765 
      elif fid == 2:
4444 rajveer 11766 
        if ftype == TType.I64:
11767 
          self.warehouseId = iprot.readI64();
11768 
        else:
11769 
          iprot.skip(ftype)
11770 
      elif fid == 3:
3064 chandransh 11771 
        if ftype == TType.STRING:
4394 rajveer 11772 
          self.description = iprot.readString();
3064 chandransh 11773 
        else:
11774 
          iprot.skip(ftype)
94 ashish 11775 
      else:
11776 
        iprot.skip(ftype)
11777 
      iprot.readFieldEnd()
11778 
    iprot.readStructEnd()
11779 
 
11780 
  def write(self, oprot):
11781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11783 
      return
4394 rajveer 11784 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11785 
    if self.type is not None:
4394 rajveer 11786 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11787 
      oprot.writeI64(self.type)
11788 
      oprot.writeFieldEnd()
4444 rajveer 11789 
    if self.warehouseId is not None:
11790 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11791 
      oprot.writeI64(self.warehouseId)
11792 
      oprot.writeFieldEnd()
4394 rajveer 11793 
    if self.description is not None:
4444 rajveer 11794 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11795 
      oprot.writeString(self.description)
3064 chandransh 11796 
      oprot.writeFieldEnd()
94 ashish 11797 
    oprot.writeFieldStop()
11798 
    oprot.writeStructEnd()
11799 
 
3431 rajveer 11800 
  def validate(self):
11801 
    return
11802 
 
11803 
 
94 ashish 11804 
  def __repr__(self):
11805 
    L = ['%s=%r' % (key, value)
11806 
      for key, value in self.__dict__.iteritems()]
11807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11808 
 
11809 
  def __eq__(self, other):
11810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11811 
 
11812 
  def __ne__(self, other):
11813 
    return not (self == other)
11814 
 
4394 rajveer 11815 
class addAlert_result:
3064 chandransh 11816 
 
11817 
  thrift_spec = (
11818 
  )
11819 
 
11820 
  def read(self, iprot):
11821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11823 
      return
11824 
    iprot.readStructBegin()
11825 
    while True:
11826 
      (fname, ftype, fid) = iprot.readFieldBegin()
11827 
      if ftype == TType.STOP:
11828 
        break
11829 
      else:
11830 
        iprot.skip(ftype)
11831 
      iprot.readFieldEnd()
11832 
    iprot.readStructEnd()
11833 
 
11834 
  def write(self, oprot):
11835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11837 
      return
4394 rajveer 11838 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11839 
    oprot.writeFieldStop()
11840 
    oprot.writeStructEnd()
11841 
 
3431 rajveer 11842 
  def validate(self):
11843 
    return
11844 
 
11845 
 
3064 chandransh 11846 
  def __repr__(self):
11847 
    L = ['%s=%r' % (key, value)
11848 
      for key, value in self.__dict__.iteritems()]
11849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11850 
 
11851 
  def __eq__(self, other):
11852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11853 
 
11854 
  def __ne__(self, other):
11855 
    return not (self == other)
11856 
 
4444 rajveer 11857 
class markAlertsAsSeen_args:
11858 
  """
11859 
  Attributes:
11860 
   - warehouseId
11861 
  """
11862 
 
11863 
  thrift_spec = (
11864 
    None, # 0
11865 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11866 
  )
11867 
 
11868 
  def __init__(self, warehouseId=None,):
11869 
    self.warehouseId = warehouseId
11870 
 
11871 
  def read(self, iprot):
11872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11874 
      return
11875 
    iprot.readStructBegin()
11876 
    while True:
11877 
      (fname, ftype, fid) = iprot.readFieldBegin()
11878 
      if ftype == TType.STOP:
11879 
        break
11880 
      if fid == 1:
11881 
        if ftype == TType.I64:
11882 
          self.warehouseId = iprot.readI64();
11883 
        else:
11884 
          iprot.skip(ftype)
11885 
      else:
11886 
        iprot.skip(ftype)
11887 
      iprot.readFieldEnd()
11888 
    iprot.readStructEnd()
11889 
 
11890 
  def write(self, oprot):
11891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11893 
      return
11894 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11895 
    if self.warehouseId is not None:
11896 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11897 
      oprot.writeI64(self.warehouseId)
11898 
      oprot.writeFieldEnd()
11899 
    oprot.writeFieldStop()
11900 
    oprot.writeStructEnd()
11901 
 
11902 
  def validate(self):
11903 
    return
11904 
 
11905 
 
11906 
  def __repr__(self):
11907 
    L = ['%s=%r' % (key, value)
11908 
      for key, value in self.__dict__.iteritems()]
11909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11910 
 
11911 
  def __eq__(self, other):
11912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11913 
 
11914 
  def __ne__(self, other):
11915 
    return not (self == other)
11916 
 
11917 
class markAlertsAsSeen_result:
11918 
 
11919 
  thrift_spec = (
11920 
  )
11921 
 
11922 
  def read(self, iprot):
11923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11925 
      return
11926 
    iprot.readStructBegin()
11927 
    while True:
11928 
      (fname, ftype, fid) = iprot.readFieldBegin()
11929 
      if ftype == TType.STOP:
11930 
        break
11931 
      else:
11932 
        iprot.skip(ftype)
11933 
      iprot.readFieldEnd()
11934 
    iprot.readStructEnd()
11935 
 
11936 
  def write(self, oprot):
11937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11939 
      return
11940 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11941 
    oprot.writeFieldStop()
11942 
    oprot.writeStructEnd()
11943 
 
11944 
  def validate(self):
11945 
    return
11946 
 
11947 
 
11948 
  def __repr__(self):
11949 
    L = ['%s=%r' % (key, value)
11950 
      for key, value in self.__dict__.iteritems()]
11951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11952 
 
11953 
  def __eq__(self, other):
11954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11955 
 
11956 
  def __ne__(self, other):
11957 
    return not (self == other)
11958 
 
3064 chandransh 11959 
class getValidOrderCount_args:
11960 
 
11961 
  thrift_spec = (
11962 
  )
11963 
 
11964 
  def read(self, iprot):
11965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11967 
      return
11968 
    iprot.readStructBegin()
11969 
    while True:
11970 
      (fname, ftype, fid) = iprot.readFieldBegin()
11971 
      if ftype == TType.STOP:
11972 
        break
11973 
      else:
11974 
        iprot.skip(ftype)
11975 
      iprot.readFieldEnd()
11976 
    iprot.readStructEnd()
11977 
 
11978 
  def write(self, oprot):
11979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11981 
      return
11982 
    oprot.writeStructBegin('getValidOrderCount_args')
11983 
    oprot.writeFieldStop()
11984 
    oprot.writeStructEnd()
11985 
 
3431 rajveer 11986 
  def validate(self):
11987 
    return
11988 
 
11989 
 
3064 chandransh 11990 
  def __repr__(self):
11991 
    L = ['%s=%r' % (key, value)
11992 
      for key, value in self.__dict__.iteritems()]
11993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11994 
 
11995 
  def __eq__(self, other):
11996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11997 
 
11998 
  def __ne__(self, other):
11999 
    return not (self == other)
12000 
 
12001 
class getValidOrderCount_result:
94 ashish 12002 
  """
12003 
  Attributes:
12004 
   - success
12005 
  """
12006 
 
12007 
  thrift_spec = (
3064 chandransh 12008 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12009 
  )
12010 
 
3064 chandransh 12011 
  def __init__(self, success=None,):
94 ashish 12012 
    self.success = success
12013 
 
12014 
  def read(self, iprot):
12015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12017 
      return
12018 
    iprot.readStructBegin()
12019 
    while True:
12020 
      (fname, ftype, fid) = iprot.readFieldBegin()
12021 
      if ftype == TType.STOP:
12022 
        break
12023 
      if fid == 0:
3064 chandransh 12024 
        if ftype == TType.I64:
12025 
          self.success = iprot.readI64();
94 ashish 12026 
        else:
12027 
          iprot.skip(ftype)
12028 
      else:
12029 
        iprot.skip(ftype)
12030 
      iprot.readFieldEnd()
12031 
    iprot.readStructEnd()
12032 
 
12033 
  def write(self, oprot):
12034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12036 
      return
3064 chandransh 12037 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12038 
    if self.success is not None:
3064 chandransh 12039 
      oprot.writeFieldBegin('success', TType.I64, 0)
12040 
      oprot.writeI64(self.success)
94 ashish 12041 
      oprot.writeFieldEnd()
12042 
    oprot.writeFieldStop()
12043 
    oprot.writeStructEnd()
12044 
 
3431 rajveer 12045 
  def validate(self):
12046 
    return
12047 
 
12048 
 
94 ashish 12049 
  def __repr__(self):
12050 
    L = ['%s=%r' % (key, value)
12051 
      for key, value in self.__dict__.iteritems()]
12052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12053 
 
12054 
  def __eq__(self, other):
12055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12056 
 
12057 
  def __ne__(self, other):
12058 
    return not (self == other)
12059 
 
3064 chandransh 12060 
class getNoOfCustomersWithSuccessfulTransaction_args:
12061 
 
12062 
  thrift_spec = (
12063 
  )
12064 
 
12065 
  def read(self, iprot):
12066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12068 
      return
12069 
    iprot.readStructBegin()
12070 
    while True:
12071 
      (fname, ftype, fid) = iprot.readFieldBegin()
12072 
      if ftype == TType.STOP:
12073 
        break
12074 
      else:
12075 
        iprot.skip(ftype)
12076 
      iprot.readFieldEnd()
12077 
    iprot.readStructEnd()
12078 
 
12079 
  def write(self, oprot):
12080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12082 
      return
12083 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12084 
    oprot.writeFieldStop()
12085 
    oprot.writeStructEnd()
12086 
 
3431 rajveer 12087 
  def validate(self):
12088 
    return
12089 
 
12090 
 
3064 chandransh 12091 
  def __repr__(self):
12092 
    L = ['%s=%r' % (key, value)
12093 
      for key, value in self.__dict__.iteritems()]
12094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12095 
 
12096 
  def __eq__(self, other):
12097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12098 
 
12099 
  def __ne__(self, other):
12100 
    return not (self == other)
12101 
 
12102 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12103 
  """
12104 
  Attributes:
3064 chandransh 12105 
   - success
94 ashish 12106 
  """
12107 
 
12108 
  thrift_spec = (
3064 chandransh 12109 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12110 
  )
12111 
 
3064 chandransh 12112 
  def __init__(self, success=None,):
12113 
    self.success = success
94 ashish 12114 
 
12115 
  def read(self, iprot):
12116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12118 
      return
12119 
    iprot.readStructBegin()
12120 
    while True:
12121 
      (fname, ftype, fid) = iprot.readFieldBegin()
12122 
      if ftype == TType.STOP:
12123 
        break
3064 chandransh 12124 
      if fid == 0:
94 ashish 12125 
        if ftype == TType.I64:
3064 chandransh 12126 
          self.success = iprot.readI64();
94 ashish 12127 
        else:
12128 
          iprot.skip(ftype)
12129 
      else:
12130 
        iprot.skip(ftype)
12131 
      iprot.readFieldEnd()
12132 
    iprot.readStructEnd()
12133 
 
12134 
  def write(self, oprot):
12135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12137 
      return
3064 chandransh 12138 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12139 
    if self.success is not None:
3064 chandransh 12140 
      oprot.writeFieldBegin('success', TType.I64, 0)
12141 
      oprot.writeI64(self.success)
94 ashish 12142 
      oprot.writeFieldEnd()
12143 
    oprot.writeFieldStop()
12144 
    oprot.writeStructEnd()
12145 
 
3431 rajveer 12146 
  def validate(self):
12147 
    return
12148 
 
12149 
 
94 ashish 12150 
  def __repr__(self):
12151 
    L = ['%s=%r' % (key, value)
12152 
      for key, value in self.__dict__.iteritems()]
12153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12154 
 
12155 
  def __eq__(self, other):
12156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12157 
 
12158 
  def __ne__(self, other):
12159 
    return not (self == other)
12160 
 
3064 chandransh 12161 
class getValidOrdersAmountRange_args:
12162 
 
12163 
  thrift_spec = (
12164 
  )
12165 
 
12166 
  def read(self, iprot):
12167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12169 
      return
12170 
    iprot.readStructBegin()
12171 
    while True:
12172 
      (fname, ftype, fid) = iprot.readFieldBegin()
12173 
      if ftype == TType.STOP:
12174 
        break
12175 
      else:
12176 
        iprot.skip(ftype)
12177 
      iprot.readFieldEnd()
12178 
    iprot.readStructEnd()
12179 
 
12180 
  def write(self, oprot):
12181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12183 
      return
12184 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12185 
    oprot.writeFieldStop()
12186 
    oprot.writeStructEnd()
12187 
 
3431 rajveer 12188 
  def validate(self):
12189 
    return
12190 
 
12191 
 
3064 chandransh 12192 
  def __repr__(self):
12193 
    L = ['%s=%r' % (key, value)
12194 
      for key, value in self.__dict__.iteritems()]
12195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12196 
 
12197 
  def __eq__(self, other):
12198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12199 
 
12200 
  def __ne__(self, other):
12201 
    return not (self == other)
12202 
 
12203 
class getValidOrdersAmountRange_result:
94 ashish 12204 
  """
12205 
  Attributes:
12206 
   - success
12207 
  """
12208 
 
12209 
  thrift_spec = (
3064 chandransh 12210 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12211 
  )
12212 
 
3064 chandransh 12213 
  def __init__(self, success=None,):
94 ashish 12214 
    self.success = success
12215 
 
12216 
  def read(self, iprot):
12217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12219 
      return
12220 
    iprot.readStructBegin()
12221 
    while True:
12222 
      (fname, ftype, fid) = iprot.readFieldBegin()
12223 
      if ftype == TType.STOP:
12224 
        break
12225 
      if fid == 0:
483 rajveer 12226 
        if ftype == TType.LIST:
12227 
          self.success = []
6031 rajveer 12228 
          (_etype206, _size203) = iprot.readListBegin()
12229 
          for _i207 in xrange(_size203):
12230 
            _elem208 = iprot.readDouble();
12231 
            self.success.append(_elem208)
483 rajveer 12232 
          iprot.readListEnd()
94 ashish 12233 
        else:
12234 
          iprot.skip(ftype)
12235 
      else:
12236 
        iprot.skip(ftype)
12237 
      iprot.readFieldEnd()
12238 
    iprot.readStructEnd()
12239 
 
12240 
  def write(self, oprot):
12241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12243 
      return
3064 chandransh 12244 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12245 
    if self.success is not None:
483 rajveer 12246 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12247 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6031 rajveer 12248 
      for iter209 in self.success:
12249 
        oprot.writeDouble(iter209)
483 rajveer 12250 
      oprot.writeListEnd()
94 ashish 12251 
      oprot.writeFieldEnd()
12252 
    oprot.writeFieldStop()
12253 
    oprot.writeStructEnd()
12254 
 
3431 rajveer 12255 
  def validate(self):
12256 
    return
12257 
 
12258 
 
94 ashish 12259 
  def __repr__(self):
12260 
    L = ['%s=%r' % (key, value)
12261 
      for key, value in self.__dict__.iteritems()]
12262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12263 
 
12264 
  def __eq__(self, other):
12265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12266 
 
12267 
  def __ne__(self, other):
12268 
    return not (self == other)
12269 
 
3064 chandransh 12270 
class getValidOrders_args:
1528 ankur.sing 12271 
  """
12272 
  Attributes:
3064 chandransh 12273 
   - limit
5874 rajveer 12274 
   - onlyStore
1528 ankur.sing 12275 
  """
12276 
 
12277 
  thrift_spec = (
12278 
    None, # 0
3064 chandransh 12279 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12280 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12281 
  )
12282 
 
5874 rajveer 12283 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12284 
    self.limit = limit
5874 rajveer 12285 
    self.onlyStore = onlyStore
1528 ankur.sing 12286 
 
12287 
  def read(self, iprot):
12288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12290 
      return
12291 
    iprot.readStructBegin()
12292 
    while True:
12293 
      (fname, ftype, fid) = iprot.readFieldBegin()
12294 
      if ftype == TType.STOP:
12295 
        break
12296 
      if fid == 1:
12297 
        if ftype == TType.I64:
3064 chandransh 12298 
          self.limit = iprot.readI64();
1528 ankur.sing 12299 
        else:
12300 
          iprot.skip(ftype)
5874 rajveer 12301 
      elif fid == 2:
12302 
        if ftype == TType.BOOL:
12303 
          self.onlyStore = iprot.readBool();
12304 
        else:
12305 
          iprot.skip(ftype)
1528 ankur.sing 12306 
      else:
12307 
        iprot.skip(ftype)
12308 
      iprot.readFieldEnd()
12309 
    iprot.readStructEnd()
12310 
 
12311 
  def write(self, oprot):
12312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12314 
      return
3064 chandransh 12315 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12316 
    if self.limit is not None:
3064 chandransh 12317 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12318 
      oprot.writeI64(self.limit)
1528 ankur.sing 12319 
      oprot.writeFieldEnd()
5874 rajveer 12320 
    if self.onlyStore is not None:
12321 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12322 
      oprot.writeBool(self.onlyStore)
12323 
      oprot.writeFieldEnd()
1528 ankur.sing 12324 
    oprot.writeFieldStop()
12325 
    oprot.writeStructEnd()
12326 
 
3431 rajveer 12327 
  def validate(self):
12328 
    return
12329 
 
12330 
 
1528 ankur.sing 12331 
  def __repr__(self):
12332 
    L = ['%s=%r' % (key, value)
12333 
      for key, value in self.__dict__.iteritems()]
12334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12335 
 
12336 
  def __eq__(self, other):
12337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12338 
 
12339 
  def __ne__(self, other):
12340 
    return not (self == other)
12341 
 
3064 chandransh 12342 
class getValidOrders_result:
1528 ankur.sing 12343 
  """
12344 
  Attributes:
12345 
   - success
12346 
  """
12347 
 
12348 
  thrift_spec = (
3064 chandransh 12349 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12350 
  )
12351 
 
3064 chandransh 12352 
  def __init__(self, success=None,):
1528 ankur.sing 12353 
    self.success = success
12354 
 
12355 
  def read(self, iprot):
12356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12358 
      return
12359 
    iprot.readStructBegin()
12360 
    while True:
12361 
      (fname, ftype, fid) = iprot.readFieldBegin()
12362 
      if ftype == TType.STOP:
12363 
        break
12364 
      if fid == 0:
3064 chandransh 12365 
        if ftype == TType.LIST:
12366 
          self.success = []
6031 rajveer 12367 
          (_etype213, _size210) = iprot.readListBegin()
12368 
          for _i214 in xrange(_size210):
12369 
            _elem215 = Order()
12370 
            _elem215.read(iprot)
12371 
            self.success.append(_elem215)
3064 chandransh 12372 
          iprot.readListEnd()
1528 ankur.sing 12373 
        else:
12374 
          iprot.skip(ftype)
12375 
      else:
12376 
        iprot.skip(ftype)
12377 
      iprot.readFieldEnd()
12378 
    iprot.readStructEnd()
12379 
 
12380 
  def write(self, oprot):
12381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12383 
      return
3064 chandransh 12384 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12385 
    if self.success is not None:
3064 chandransh 12386 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12387 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12388 
      for iter216 in self.success:
12389 
        iter216.write(oprot)
3064 chandransh 12390 
      oprot.writeListEnd()
1528 ankur.sing 12391 
      oprot.writeFieldEnd()
12392 
    oprot.writeFieldStop()
12393 
    oprot.writeStructEnd()
12394 
 
3431 rajveer 12395 
  def validate(self):
12396 
    return
12397 
 
12398 
 
1528 ankur.sing 12399 
  def __repr__(self):
12400 
    L = ['%s=%r' % (key, value)
12401 
      for key, value in self.__dict__.iteritems()]
12402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12403 
 
12404 
  def __eq__(self, other):
12405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12406 
 
12407 
  def __ne__(self, other):
12408 
    return not (self == other)
12409 
 
1220 chandransh 12410 
class batchOrders_args:
12411 
  """
12412 
  Attributes:
12413 
   - warehouseId
12414 
  """
12415 
 
12416 
  thrift_spec = (
12417 
    None, # 0
12418 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12419 
  )
12420 
 
12421 
  def __init__(self, warehouseId=None,):
12422 
    self.warehouseId = warehouseId
12423 
 
12424 
  def read(self, iprot):
12425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12427 
      return
12428 
    iprot.readStructBegin()
12429 
    while True:
12430 
      (fname, ftype, fid) = iprot.readFieldBegin()
12431 
      if ftype == TType.STOP:
12432 
        break
12433 
      if fid == 1:
12434 
        if ftype == TType.I64:
12435 
          self.warehouseId = iprot.readI64();
12436 
        else:
12437 
          iprot.skip(ftype)
12438 
      else:
12439 
        iprot.skip(ftype)
12440 
      iprot.readFieldEnd()
12441 
    iprot.readStructEnd()
12442 
 
12443 
  def write(self, oprot):
12444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12446 
      return
12447 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12448 
    if self.warehouseId is not None:
1220 chandransh 12449 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12450 
      oprot.writeI64(self.warehouseId)
12451 
      oprot.writeFieldEnd()
12452 
    oprot.writeFieldStop()
12453 
    oprot.writeStructEnd()
12454 
 
3431 rajveer 12455 
  def validate(self):
12456 
    return
12457 
 
12458 
 
1220 chandransh 12459 
  def __repr__(self):
12460 
    L = ['%s=%r' % (key, value)
12461 
      for key, value in self.__dict__.iteritems()]
12462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12463 
 
12464 
  def __eq__(self, other):
12465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12466 
 
12467 
  def __ne__(self, other):
12468 
    return not (self == other)
12469 
 
12470 
class batchOrders_result:
12471 
  """
12472 
  Attributes:
12473 
   - success
12474 
   - ex
12475 
  """
12476 
 
12477 
  thrift_spec = (
12478 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12479 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12480 
  )
12481 
 
12482 
  def __init__(self, success=None, ex=None,):
12483 
    self.success = success
12484 
    self.ex = ex
12485 
 
12486 
  def read(self, iprot):
12487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12489 
      return
12490 
    iprot.readStructBegin()
12491 
    while True:
12492 
      (fname, ftype, fid) = iprot.readFieldBegin()
12493 
      if ftype == TType.STOP:
12494 
        break
12495 
      if fid == 0:
12496 
        if ftype == TType.LIST:
12497 
          self.success = []
6031 rajveer 12498 
          (_etype220, _size217) = iprot.readListBegin()
12499 
          for _i221 in xrange(_size217):
12500 
            _elem222 = Order()
12501 
            _elem222.read(iprot)
12502 
            self.success.append(_elem222)
1220 chandransh 12503 
          iprot.readListEnd()
12504 
        else:
12505 
          iprot.skip(ftype)
12506 
      elif fid == 1:
12507 
        if ftype == TType.STRUCT:
12508 
          self.ex = TransactionServiceException()
12509 
          self.ex.read(iprot)
12510 
        else:
12511 
          iprot.skip(ftype)
12512 
      else:
12513 
        iprot.skip(ftype)
12514 
      iprot.readFieldEnd()
12515 
    iprot.readStructEnd()
12516 
 
12517 
  def write(self, oprot):
12518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12520 
      return
12521 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12522 
    if self.success is not None:
1220 chandransh 12523 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12524 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12525 
      for iter223 in self.success:
12526 
        iter223.write(oprot)
1220 chandransh 12527 
      oprot.writeListEnd()
12528 
      oprot.writeFieldEnd()
3431 rajveer 12529 
    if self.ex is not None:
1220 chandransh 12530 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12531 
      self.ex.write(oprot)
12532 
      oprot.writeFieldEnd()
12533 
    oprot.writeFieldStop()
12534 
    oprot.writeStructEnd()
12535 
 
3431 rajveer 12536 
  def validate(self):
12537 
    return
12538 
 
12539 
 
1220 chandransh 12540 
  def __repr__(self):
12541 
    L = ['%s=%r' % (key, value)
12542 
      for key, value in self.__dict__.iteritems()]
12543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12544 
 
12545 
  def __eq__(self, other):
12546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12547 
 
12548 
  def __ne__(self, other):
12549 
    return not (self == other)
12550 
 
1208 chandransh 12551 
class markOrderAsOutOfStock_args:
12552 
  """
12553 
  Attributes:
12554 
   - orderId
12555 
  """
12556 
 
12557 
  thrift_spec = (
12558 
    None, # 0
12559 
    (1, TType.I64, 'orderId', None, None, ), # 1
12560 
  )
12561 
 
12562 
  def __init__(self, orderId=None,):
12563 
    self.orderId = orderId
12564 
 
12565 
  def read(self, iprot):
12566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12568 
      return
12569 
    iprot.readStructBegin()
12570 
    while True:
12571 
      (fname, ftype, fid) = iprot.readFieldBegin()
12572 
      if ftype == TType.STOP:
12573 
        break
12574 
      if fid == 1:
12575 
        if ftype == TType.I64:
12576 
          self.orderId = iprot.readI64();
12577 
        else:
12578 
          iprot.skip(ftype)
12579 
      else:
12580 
        iprot.skip(ftype)
12581 
      iprot.readFieldEnd()
12582 
    iprot.readStructEnd()
12583 
 
12584 
  def write(self, oprot):
12585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12587 
      return
12588 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12589 
    if self.orderId is not None:
1208 chandransh 12590 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12591 
      oprot.writeI64(self.orderId)
12592 
      oprot.writeFieldEnd()
12593 
    oprot.writeFieldStop()
12594 
    oprot.writeStructEnd()
12595 
 
3431 rajveer 12596 
  def validate(self):
12597 
    return
12598 
 
12599 
 
1208 chandransh 12600 
  def __repr__(self):
12601 
    L = ['%s=%r' % (key, value)
12602 
      for key, value in self.__dict__.iteritems()]
12603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12604 
 
12605 
  def __eq__(self, other):
12606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12607 
 
12608 
  def __ne__(self, other):
12609 
    return not (self == other)
12610 
 
12611 
class markOrderAsOutOfStock_result:
12612 
  """
12613 
  Attributes:
12614 
   - success
12615 
   - ex
12616 
  """
12617 
 
12618 
  thrift_spec = (
12619 
    (0, TType.BOOL, 'success', None, None, ), # 0
12620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12621 
  )
12622 
 
12623 
  def __init__(self, success=None, ex=None,):
12624 
    self.success = success
12625 
    self.ex = ex
12626 
 
12627 
  def read(self, iprot):
12628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12630 
      return
12631 
    iprot.readStructBegin()
12632 
    while True:
12633 
      (fname, ftype, fid) = iprot.readFieldBegin()
12634 
      if ftype == TType.STOP:
12635 
        break
12636 
      if fid == 0:
12637 
        if ftype == TType.BOOL:
12638 
          self.success = iprot.readBool();
12639 
        else:
12640 
          iprot.skip(ftype)
12641 
      elif fid == 1:
12642 
        if ftype == TType.STRUCT:
12643 
          self.ex = TransactionServiceException()
12644 
          self.ex.read(iprot)
12645 
        else:
12646 
          iprot.skip(ftype)
12647 
      else:
12648 
        iprot.skip(ftype)
12649 
      iprot.readFieldEnd()
12650 
    iprot.readStructEnd()
12651 
 
12652 
  def write(self, oprot):
12653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12655 
      return
12656 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12657 
    if self.success is not None:
1208 chandransh 12658 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12659 
      oprot.writeBool(self.success)
12660 
      oprot.writeFieldEnd()
3431 rajveer 12661 
    if self.ex is not None:
1208 chandransh 12662 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12663 
      self.ex.write(oprot)
12664 
      oprot.writeFieldEnd()
12665 
    oprot.writeFieldStop()
12666 
    oprot.writeStructEnd()
12667 
 
3431 rajveer 12668 
  def validate(self):
12669 
    return
12670 
 
12671 
 
1208 chandransh 12672 
  def __repr__(self):
12673 
    L = ['%s=%r' % (key, value)
12674 
      for key, value in self.__dict__.iteritems()]
12675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12676 
 
12677 
  def __eq__(self, other):
12678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12679 
 
12680 
  def __ne__(self, other):
12681 
    return not (self == other)
12682 
 
3064 chandransh 12683 
class verifyOrder_args:
759 chandransh 12684 
  """
12685 
  Attributes:
3064 chandransh 12686 
   - orderId
759 chandransh 12687 
  """
12688 
 
12689 
  thrift_spec = (
12690 
    None, # 0
3064 chandransh 12691 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12692 
  )
12693 
 
3064 chandransh 12694 
  def __init__(self, orderId=None,):
12695 
    self.orderId = orderId
759 chandransh 12696 
 
12697 
  def read(self, iprot):
12698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12700 
      return
12701 
    iprot.readStructBegin()
12702 
    while True:
12703 
      (fname, ftype, fid) = iprot.readFieldBegin()
12704 
      if ftype == TType.STOP:
12705 
        break
12706 
      if fid == 1:
12707 
        if ftype == TType.I64:
3064 chandransh 12708 
          self.orderId = iprot.readI64();
759 chandransh 12709 
        else:
12710 
          iprot.skip(ftype)
12711 
      else:
12712 
        iprot.skip(ftype)
12713 
      iprot.readFieldEnd()
12714 
    iprot.readStructEnd()
12715 
 
12716 
  def write(self, oprot):
12717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12719 
      return
3064 chandransh 12720 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12721 
    if self.orderId is not None:
3064 chandransh 12722 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12723 
      oprot.writeI64(self.orderId)
759 chandransh 12724 
      oprot.writeFieldEnd()
12725 
    oprot.writeFieldStop()
12726 
    oprot.writeStructEnd()
12727 
 
3431 rajveer 12728 
  def validate(self):
12729 
    return
12730 
 
12731 
 
759 chandransh 12732 
  def __repr__(self):
12733 
    L = ['%s=%r' % (key, value)
12734 
      for key, value in self.__dict__.iteritems()]
12735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12736 
 
12737 
  def __eq__(self, other):
12738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12739 
 
12740 
  def __ne__(self, other):
12741 
    return not (self == other)
12742 
 
3064 chandransh 12743 
class verifyOrder_result:
759 chandransh 12744 
  """
12745 
  Attributes:
12746 
   - success
12747 
   - ex
12748 
  """
12749 
 
12750 
  thrift_spec = (
12751 
    (0, TType.BOOL, 'success', None, None, ), # 0
12752 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12753 
  )
12754 
 
12755 
  def __init__(self, success=None, ex=None,):
12756 
    self.success = success
12757 
    self.ex = ex
12758 
 
12759 
  def read(self, iprot):
12760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12762 
      return
12763 
    iprot.readStructBegin()
12764 
    while True:
12765 
      (fname, ftype, fid) = iprot.readFieldBegin()
12766 
      if ftype == TType.STOP:
12767 
        break
12768 
      if fid == 0:
12769 
        if ftype == TType.BOOL:
12770 
          self.success = iprot.readBool();
12771 
        else:
12772 
          iprot.skip(ftype)
12773 
      elif fid == 1:
12774 
        if ftype == TType.STRUCT:
12775 
          self.ex = TransactionServiceException()
12776 
          self.ex.read(iprot)
12777 
        else:
12778 
          iprot.skip(ftype)
12779 
      else:
12780 
        iprot.skip(ftype)
12781 
      iprot.readFieldEnd()
12782 
    iprot.readStructEnd()
12783 
 
12784 
  def write(self, oprot):
12785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12787 
      return
3064 chandransh 12788 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12789 
    if self.success is not None:
759 chandransh 12790 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12791 
      oprot.writeBool(self.success)
12792 
      oprot.writeFieldEnd()
3431 rajveer 12793 
    if self.ex is not None:
759 chandransh 12794 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12795 
      self.ex.write(oprot)
12796 
      oprot.writeFieldEnd()
12797 
    oprot.writeFieldStop()
12798 
    oprot.writeStructEnd()
12799 
 
3431 rajveer 12800 
  def validate(self):
12801 
    return
12802 
 
12803 
 
759 chandransh 12804 
  def __repr__(self):
12805 
    L = ['%s=%r' % (key, value)
12806 
      for key, value in self.__dict__.iteritems()]
12807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12808 
 
12809 
  def __eq__(self, other):
12810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12811 
 
12812 
  def __ne__(self, other):
12813 
    return not (self == other)
12814 
 
3064 chandransh 12815 
class acceptOrder_args:
1113 chandransh 12816 
  """
12817 
  Attributes:
3064 chandransh 12818 
   - orderId
1113 chandransh 12819 
  """
12820 
 
12821 
  thrift_spec = (
12822 
    None, # 0
3064 chandransh 12823 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12824 
  )
12825 
 
3064 chandransh 12826 
  def __init__(self, orderId=None,):
12827 
    self.orderId = orderId
1113 chandransh 12828 
 
12829 
  def read(self, iprot):
12830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12832 
      return
12833 
    iprot.readStructBegin()
12834 
    while True:
12835 
      (fname, ftype, fid) = iprot.readFieldBegin()
12836 
      if ftype == TType.STOP:
12837 
        break
12838 
      if fid == 1:
12839 
        if ftype == TType.I64:
3064 chandransh 12840 
          self.orderId = iprot.readI64();
1113 chandransh 12841 
        else:
12842 
          iprot.skip(ftype)
12843 
      else:
12844 
        iprot.skip(ftype)
12845 
      iprot.readFieldEnd()
12846 
    iprot.readStructEnd()
12847 
 
12848 
  def write(self, oprot):
12849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12851 
      return
3064 chandransh 12852 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12853 
    if self.orderId is not None:
3064 chandransh 12854 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12855 
      oprot.writeI64(self.orderId)
1113 chandransh 12856 
      oprot.writeFieldEnd()
12857 
    oprot.writeFieldStop()
12858 
    oprot.writeStructEnd()
12859 
 
3431 rajveer 12860 
  def validate(self):
12861 
    return
12862 
 
12863 
 
1113 chandransh 12864 
  def __repr__(self):
12865 
    L = ['%s=%r' % (key, value)
12866 
      for key, value in self.__dict__.iteritems()]
12867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12868 
 
12869 
  def __eq__(self, other):
12870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12871 
 
12872 
  def __ne__(self, other):
12873 
    return not (self == other)
12874 
 
3064 chandransh 12875 
class acceptOrder_result:
1113 chandransh 12876 
  """
12877 
  Attributes:
12878 
   - success
12879 
   - ex
12880 
  """
12881 
 
12882 
  thrift_spec = (
3064 chandransh 12883 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12884 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12885 
  )
12886 
 
12887 
  def __init__(self, success=None, ex=None,):
12888 
    self.success = success
12889 
    self.ex = ex
12890 
 
12891 
  def read(self, iprot):
12892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12894 
      return
12895 
    iprot.readStructBegin()
12896 
    while True:
12897 
      (fname, ftype, fid) = iprot.readFieldBegin()
12898 
      if ftype == TType.STOP:
12899 
        break
12900 
      if fid == 0:
3064 chandransh 12901 
        if ftype == TType.BOOL:
12902 
          self.success = iprot.readBool();
1113 chandransh 12903 
        else:
12904 
          iprot.skip(ftype)
12905 
      elif fid == 1:
12906 
        if ftype == TType.STRUCT:
12907 
          self.ex = TransactionServiceException()
12908 
          self.ex.read(iprot)
12909 
        else:
12910 
          iprot.skip(ftype)
12911 
      else:
12912 
        iprot.skip(ftype)
12913 
      iprot.readFieldEnd()
12914 
    iprot.readStructEnd()
12915 
 
12916 
  def write(self, oprot):
12917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12919 
      return
3064 chandransh 12920 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12921 
    if self.success is not None:
3064 chandransh 12922 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12923 
      oprot.writeBool(self.success)
1113 chandransh 12924 
      oprot.writeFieldEnd()
3431 rajveer 12925 
    if self.ex is not None:
1113 chandransh 12926 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12927 
      self.ex.write(oprot)
12928 
      oprot.writeFieldEnd()
12929 
    oprot.writeFieldStop()
12930 
    oprot.writeStructEnd()
12931 
 
3431 rajveer 12932 
  def validate(self):
12933 
    return
12934 
 
12935 
 
1113 chandransh 12936 
  def __repr__(self):
12937 
    L = ['%s=%r' % (key, value)
12938 
      for key, value in self.__dict__.iteritems()]
12939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12940 
 
12941 
  def __eq__(self, other):
12942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12943 
 
12944 
  def __ne__(self, other):
12945 
    return not (self == other)
12946 
 
3064 chandransh 12947 
class addBillingDetails_args:
1135 chandransh 12948 
  """
12949 
  Attributes:
3064 chandransh 12950 
   - orderId
12951 
   - invoice_number
4658 mandeep.dh 12952 
   - serialNumber
4283 anupam.sin 12953 
   - itemNumber
3064 chandransh 12954 
   - billed_by
4264 rajveer 12955 
   - jacketNumber
4283 anupam.sin 12956 
   - billingType
5110 mandeep.dh 12957 
   - fulfilmentWarehouseId
4763 rajveer 12958 
   - authorize
1135 chandransh 12959 
  """
12960 
 
12961 
  thrift_spec = (
12962 
    None, # 0
3064 chandransh 12963 
    (1, TType.I64, 'orderId', None, None, ), # 1
12964 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12965 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12966 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12967 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12968 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12969 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12970 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12971 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12972 
  )
12973 
 
5110 mandeep.dh 12974 
  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 12975 
    self.orderId = orderId
12976 
    self.invoice_number = invoice_number
4658 mandeep.dh 12977 
    self.serialNumber = serialNumber
4283 anupam.sin 12978 
    self.itemNumber = itemNumber
3064 chandransh 12979 
    self.billed_by = billed_by
4264 rajveer 12980 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12981 
    self.billingType = billingType
5110 mandeep.dh 12982 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12983 
    self.authorize = authorize
1135 chandransh 12984 
 
12985 
  def read(self, iprot):
12986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12988 
      return
12989 
    iprot.readStructBegin()
12990 
    while True:
12991 
      (fname, ftype, fid) = iprot.readFieldBegin()
12992 
      if ftype == TType.STOP:
12993 
        break
12994 
      if fid == 1:
12995 
        if ftype == TType.I64:
3064 chandransh 12996 
          self.orderId = iprot.readI64();
1135 chandransh 12997 
        else:
12998 
          iprot.skip(ftype)
12999 
      elif fid == 2:
3064 chandransh 13000 
        if ftype == TType.STRING:
13001 
          self.invoice_number = iprot.readString();
1135 chandransh 13002 
        else:
13003 
          iprot.skip(ftype)
3064 chandransh 13004 
      elif fid == 3:
5411 rajveer 13005 
        if ftype == TType.LIST:
13006 
          self.serialNumber = []
6031 rajveer 13007 
          (_etype227, _size224) = iprot.readListBegin()
13008 
          for _i228 in xrange(_size224):
13009 
            _elem229 = iprot.readString();
13010 
            self.serialNumber.append(_elem229)
5411 rajveer 13011 
          iprot.readListEnd()
3064 chandransh 13012 
        else:
13013 
          iprot.skip(ftype)
13014 
      elif fid == 4:
5411 rajveer 13015 
        if ftype == TType.LIST:
13016 
          self.itemNumber = []
6031 rajveer 13017 
          (_etype233, _size230) = iprot.readListBegin()
13018 
          for _i234 in xrange(_size230):
13019 
            _elem235 = iprot.readString();
13020 
            self.itemNumber.append(_elem235)
5411 rajveer 13021 
          iprot.readListEnd()
3064 chandransh 13022 
        else:
13023 
          iprot.skip(ftype)
13024 
      elif fid == 5:
13025 
        if ftype == TType.STRING:
4283 anupam.sin 13026 
          self.billed_by = iprot.readString();
3064 chandransh 13027 
        else:
13028 
          iprot.skip(ftype)
13029 
      elif fid == 6:
13030 
        if ftype == TType.I64:
4283 anupam.sin 13031 
          self.jacketNumber = iprot.readI64();
13032 
        else:
13033 
          iprot.skip(ftype)
13034 
      elif fid == 7:
13035 
        if ftype == TType.I64:
3064 chandransh 13036 
          self.billingType = iprot.readI64();
13037 
        else:
13038 
          iprot.skip(ftype)
4283 anupam.sin 13039 
      elif fid == 8:
13040 
        if ftype == TType.I64:
5110 mandeep.dh 13041 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13042 
        else:
13043 
          iprot.skip(ftype)
4763 rajveer 13044 
      elif fid == 9:
13045 
        if ftype == TType.BOOL:
13046 
          self.authorize = iprot.readBool();
13047 
        else:
13048 
          iprot.skip(ftype)
1246 chandransh 13049 
      else:
13050 
        iprot.skip(ftype)
13051 
      iprot.readFieldEnd()
13052 
    iprot.readStructEnd()
13053 
 
13054 
  def write(self, oprot):
13055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13057 
      return
4283 anupam.sin 13058 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13059 
    if self.orderId is not None:
3064 chandransh 13060 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13061 
      oprot.writeI64(self.orderId)
1246 chandransh 13062 
      oprot.writeFieldEnd()
4283 anupam.sin 13063 
    if self.invoice_number is not None:
13064 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13065 
      oprot.writeString(self.invoice_number)
1246 chandransh 13066 
      oprot.writeFieldEnd()
4658 mandeep.dh 13067 
    if self.serialNumber is not None:
5411 rajveer 13068 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13069 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6031 rajveer 13070 
      for iter236 in self.serialNumber:
13071 
        oprot.writeString(iter236)
5411 rajveer 13072 
      oprot.writeListEnd()
3064 chandransh 13073 
      oprot.writeFieldEnd()
3431 rajveer 13074 
    if self.itemNumber is not None:
5411 rajveer 13075 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13076 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6031 rajveer 13077 
      for iter237 in self.itemNumber:
13078 
        oprot.writeString(iter237)
5411 rajveer 13079 
      oprot.writeListEnd()
3064 chandransh 13080 
      oprot.writeFieldEnd()
4283 anupam.sin 13081 
    if self.billed_by is not None:
13082 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13083 
      oprot.writeString(self.billed_by)
3064 chandransh 13084 
      oprot.writeFieldEnd()
4283 anupam.sin 13085 
    if self.jacketNumber is not None:
13086 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13087 
      oprot.writeI64(self.jacketNumber)
13088 
      oprot.writeFieldEnd()
3431 rajveer 13089 
    if self.billingType is not None:
4283 anupam.sin 13090 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13091 
      oprot.writeI64(self.billingType)
13092 
      oprot.writeFieldEnd()
5110 mandeep.dh 13093 
    if self.fulfilmentWarehouseId is not None:
13094 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13095 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13096 
      oprot.writeFieldEnd()
4763 rajveer 13097 
    if self.authorize is not None:
13098 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13099 
      oprot.writeBool(self.authorize)
13100 
      oprot.writeFieldEnd()
1246 chandransh 13101 
    oprot.writeFieldStop()
13102 
    oprot.writeStructEnd()
13103 
 
3431 rajveer 13104 
  def validate(self):
13105 
    return
13106 
 
13107 
 
1246 chandransh 13108 
  def __repr__(self):
13109 
    L = ['%s=%r' % (key, value)
13110 
      for key, value in self.__dict__.iteritems()]
13111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13112 
 
13113 
  def __eq__(self, other):
13114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13115 
 
13116 
  def __ne__(self, other):
13117 
    return not (self == other)
13118 
 
4283 anupam.sin 13119 
class addBillingDetails_result:
1246 chandransh 13120 
  """
13121 
  Attributes:
3064 chandransh 13122 
   - success
1246 chandransh 13123 
   - ex
13124 
  """
13125 
 
13126 
  thrift_spec = (
3064 chandransh 13127 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13129 
  )
13130 
 
3064 chandransh 13131 
  def __init__(self, success=None, ex=None,):
13132 
    self.success = success
1246 chandransh 13133 
    self.ex = ex
13134 
 
13135 
  def read(self, iprot):
13136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13138 
      return
13139 
    iprot.readStructBegin()
13140 
    while True:
13141 
      (fname, ftype, fid) = iprot.readFieldBegin()
13142 
      if ftype == TType.STOP:
13143 
        break
3064 chandransh 13144 
      if fid == 0:
13145 
        if ftype == TType.BOOL:
13146 
          self.success = iprot.readBool();
13147 
        else:
13148 
          iprot.skip(ftype)
13149 
      elif fid == 1:
1246 chandransh 13150 
        if ftype == TType.STRUCT:
13151 
          self.ex = TransactionServiceException()
13152 
          self.ex.read(iprot)
13153 
        else:
13154 
          iprot.skip(ftype)
13155 
      else:
13156 
        iprot.skip(ftype)
13157 
      iprot.readFieldEnd()
13158 
    iprot.readStructEnd()
13159 
 
13160 
  def write(self, oprot):
13161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13163 
      return
4283 anupam.sin 13164 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13165 
    if self.success is not None:
3064 chandransh 13166 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13167 
      oprot.writeBool(self.success)
13168 
      oprot.writeFieldEnd()
3431 rajveer 13169 
    if self.ex is not None:
1246 chandransh 13170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13171 
      self.ex.write(oprot)
13172 
      oprot.writeFieldEnd()
13173 
    oprot.writeFieldStop()
13174 
    oprot.writeStructEnd()
13175 
 
3431 rajveer 13176 
  def validate(self):
13177 
    return
13178 
 
13179 
 
1246 chandransh 13180 
  def __repr__(self):
13181 
    L = ['%s=%r' % (key, value)
13182 
      for key, value in self.__dict__.iteritems()]
13183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13184 
 
13185 
  def __eq__(self, other):
13186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13187 
 
13188 
  def __ne__(self, other):
13189 
    return not (self == other)
13190 
 
4579 rajveer 13191 
class addInvoiceNumber_args:
13192 
  """
13193 
  Attributes:
13194 
   - orderId
13195 
   - invoiceNumber
4763 rajveer 13196 
   - color
4579 rajveer 13197 
  """
13198 
 
13199 
  thrift_spec = (
13200 
    None, # 0
13201 
    (1, TType.I64, 'orderId', None, None, ), # 1
13202 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13203 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13204 
  )
13205 
 
4763 rajveer 13206 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13207 
    self.orderId = orderId
13208 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13209 
    self.color = color
4579 rajveer 13210 
 
13211 
  def read(self, iprot):
13212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13214 
      return
13215 
    iprot.readStructBegin()
13216 
    while True:
13217 
      (fname, ftype, fid) = iprot.readFieldBegin()
13218 
      if ftype == TType.STOP:
13219 
        break
13220 
      if fid == 1:
13221 
        if ftype == TType.I64:
13222 
          self.orderId = iprot.readI64();
13223 
        else:
13224 
          iprot.skip(ftype)
13225 
      elif fid == 2:
13226 
        if ftype == TType.STRING:
13227 
          self.invoiceNumber = iprot.readString();
13228 
        else:
13229 
          iprot.skip(ftype)
4763 rajveer 13230 
      elif fid == 3:
13231 
        if ftype == TType.STRING:
13232 
          self.color = iprot.readString();
13233 
        else:
13234 
          iprot.skip(ftype)
4579 rajveer 13235 
      else:
13236 
        iprot.skip(ftype)
13237 
      iprot.readFieldEnd()
13238 
    iprot.readStructEnd()
13239 
 
13240 
  def write(self, oprot):
13241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13243 
      return
13244 
    oprot.writeStructBegin('addInvoiceNumber_args')
13245 
    if self.orderId is not None:
13246 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13247 
      oprot.writeI64(self.orderId)
13248 
      oprot.writeFieldEnd()
13249 
    if self.invoiceNumber is not None:
13250 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13251 
      oprot.writeString(self.invoiceNumber)
13252 
      oprot.writeFieldEnd()
4763 rajveer 13253 
    if self.color is not None:
13254 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13255 
      oprot.writeString(self.color)
13256 
      oprot.writeFieldEnd()
4579 rajveer 13257 
    oprot.writeFieldStop()
13258 
    oprot.writeStructEnd()
13259 
 
13260 
  def validate(self):
13261 
    return
13262 
 
13263 
 
13264 
  def __repr__(self):
13265 
    L = ['%s=%r' % (key, value)
13266 
      for key, value in self.__dict__.iteritems()]
13267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13268 
 
13269 
  def __eq__(self, other):
13270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13271 
 
13272 
  def __ne__(self, other):
13273 
    return not (self == other)
13274 
 
13275 
class addInvoiceNumber_result:
13276 
  """
13277 
  Attributes:
13278 
   - ex
13279 
  """
13280 
 
13281 
  thrift_spec = (
13282 
    None, # 0
13283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13284 
  )
13285 
 
13286 
  def __init__(self, ex=None,):
13287 
    self.ex = ex
13288 
 
13289 
  def read(self, iprot):
13290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13292 
      return
13293 
    iprot.readStructBegin()
13294 
    while True:
13295 
      (fname, ftype, fid) = iprot.readFieldBegin()
13296 
      if ftype == TType.STOP:
13297 
        break
13298 
      if fid == 1:
13299 
        if ftype == TType.STRUCT:
13300 
          self.ex = TransactionServiceException()
13301 
          self.ex.read(iprot)
13302 
        else:
13303 
          iprot.skip(ftype)
13304 
      else:
13305 
        iprot.skip(ftype)
13306 
      iprot.readFieldEnd()
13307 
    iprot.readStructEnd()
13308 
 
13309 
  def write(self, oprot):
13310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13312 
      return
13313 
    oprot.writeStructBegin('addInvoiceNumber_result')
13314 
    if self.ex is not None:
13315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13316 
      self.ex.write(oprot)
13317 
      oprot.writeFieldEnd()
13318 
    oprot.writeFieldStop()
13319 
    oprot.writeStructEnd()
13320 
 
13321 
  def validate(self):
13322 
    return
13323 
 
13324 
 
13325 
  def __repr__(self):
13326 
    L = ['%s=%r' % (key, value)
13327 
      for key, value in self.__dict__.iteritems()]
13328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13329 
 
13330 
  def __eq__(self, other):
13331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13332 
 
13333 
  def __ne__(self, other):
13334 
    return not (self == other)
13335 
 
4910 phani.kuma 13336 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13337 
  """
13338 
  Attributes:
3064 chandransh 13339 
   - warehouseId
1408 ankur.sing 13340 
   - providerId
3064 chandransh 13341 
   - cod
4910 phani.kuma 13342 
   - orderIds
1408 ankur.sing 13343 
  """
13344 
 
13345 
  thrift_spec = (
13346 
    None, # 0
3064 chandransh 13347 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13348 
    (2, TType.I64, 'providerId', None, None, ), # 2
13349 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13350 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13351 
  )
13352 
 
4910 phani.kuma 13353 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13354 
    self.warehouseId = warehouseId
1408 ankur.sing 13355 
    self.providerId = providerId
3064 chandransh 13356 
    self.cod = cod
4910 phani.kuma 13357 
    self.orderIds = orderIds
1408 ankur.sing 13358 
 
13359 
  def read(self, iprot):
13360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13362 
      return
13363 
    iprot.readStructBegin()
13364 
    while True:
13365 
      (fname, ftype, fid) = iprot.readFieldBegin()
13366 
      if ftype == TType.STOP:
13367 
        break
13368 
      if fid == 1:
13369 
        if ftype == TType.I64:
3064 chandransh 13370 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13371 
        else:
13372 
          iprot.skip(ftype)
13373 
      elif fid == 2:
13374 
        if ftype == TType.I64:
3064 chandransh 13375 
          self.providerId = iprot.readI64();
1408 ankur.sing 13376 
        else:
13377 
          iprot.skip(ftype)
3064 chandransh 13378 
      elif fid == 3:
13379 
        if ftype == TType.BOOL:
13380 
          self.cod = iprot.readBool();
13381 
        else:
13382 
          iprot.skip(ftype)
4910 phani.kuma 13383 
      elif fid == 4:
13384 
        if ftype == TType.LIST:
13385 
          self.orderIds = []
6031 rajveer 13386 
          (_etype241, _size238) = iprot.readListBegin()
13387 
          for _i242 in xrange(_size238):
13388 
            _elem243 = iprot.readI64();
13389 
            self.orderIds.append(_elem243)
4910 phani.kuma 13390 
          iprot.readListEnd()
13391 
        else:
13392 
          iprot.skip(ftype)
1408 ankur.sing 13393 
      else:
13394 
        iprot.skip(ftype)
13395 
      iprot.readFieldEnd()
13396 
    iprot.readStructEnd()
13397 
 
13398 
  def write(self, oprot):
13399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13401 
      return
4910 phani.kuma 13402 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13403 
    if self.warehouseId is not None:
3064 chandransh 13404 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13405 
      oprot.writeI64(self.warehouseId)
13406 
      oprot.writeFieldEnd()
3431 rajveer 13407 
    if self.providerId is not None:
3064 chandransh 13408 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13409 
      oprot.writeI64(self.providerId)
13410 
      oprot.writeFieldEnd()
3431 rajveer 13411 
    if self.cod is not None:
3064 chandransh 13412 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13413 
      oprot.writeBool(self.cod)
1408 ankur.sing 13414 
      oprot.writeFieldEnd()
4910 phani.kuma 13415 
    if self.orderIds is not None:
13416 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13417 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13418 
      for iter244 in self.orderIds:
13419 
        oprot.writeI64(iter244)
4910 phani.kuma 13420 
      oprot.writeListEnd()
13421 
      oprot.writeFieldEnd()
1408 ankur.sing 13422 
    oprot.writeFieldStop()
13423 
    oprot.writeStructEnd()
13424 
 
3431 rajveer 13425 
  def validate(self):
13426 
    return
13427 
 
13428 
 
1408 ankur.sing 13429 
  def __repr__(self):
13430 
    L = ['%s=%r' % (key, value)
13431 
      for key, value in self.__dict__.iteritems()]
13432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13433 
 
13434 
  def __eq__(self, other):
13435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13436 
 
13437 
  def __ne__(self, other):
13438 
    return not (self == other)
13439 
 
4910 phani.kuma 13440 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13441 
  """
13442 
  Attributes:
13443 
   - success
3064 chandransh 13444 
   - ex
1408 ankur.sing 13445 
  """
13446 
 
13447 
  thrift_spec = (
3064 chandransh 13448 
    (0, TType.BOOL, 'success', None, None, ), # 0
13449 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13450 
  )
13451 
 
3064 chandransh 13452 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13453 
    self.success = success
3064 chandransh 13454 
    self.ex = ex
1408 ankur.sing 13455 
 
13456 
  def read(self, iprot):
13457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13459 
      return
13460 
    iprot.readStructBegin()
13461 
    while True:
13462 
      (fname, ftype, fid) = iprot.readFieldBegin()
13463 
      if ftype == TType.STOP:
13464 
        break
13465 
      if fid == 0:
3064 chandransh 13466 
        if ftype == TType.BOOL:
13467 
          self.success = iprot.readBool();
1408 ankur.sing 13468 
        else:
13469 
          iprot.skip(ftype)
3064 chandransh 13470 
      elif fid == 1:
13471 
        if ftype == TType.STRUCT:
13472 
          self.ex = TransactionServiceException()
13473 
          self.ex.read(iprot)
13474 
        else:
13475 
          iprot.skip(ftype)
1408 ankur.sing 13476 
      else:
13477 
        iprot.skip(ftype)
13478 
      iprot.readFieldEnd()
13479 
    iprot.readStructEnd()
13480 
 
13481 
  def write(self, oprot):
13482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13484 
      return
4910 phani.kuma 13485 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13486 
    if self.success is not None:
3064 chandransh 13487 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13488 
      oprot.writeBool(self.success)
1408 ankur.sing 13489 
      oprot.writeFieldEnd()
3431 rajveer 13490 
    if self.ex is not None:
3064 chandransh 13491 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13492 
      self.ex.write(oprot)
13493 
      oprot.writeFieldEnd()
1408 ankur.sing 13494 
    oprot.writeFieldStop()
13495 
    oprot.writeStructEnd()
13496 
 
3431 rajveer 13497 
  def validate(self):
13498 
    return
13499 
 
13500 
 
1408 ankur.sing 13501 
  def __repr__(self):
13502 
    L = ['%s=%r' % (key, value)
13503 
      for key, value in self.__dict__.iteritems()]
13504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13505 
 
13506 
  def __eq__(self, other):
13507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13508 
 
13509 
  def __ne__(self, other):
13510 
    return not (self == other)
13511 
 
5676 rajveer 13512 
class markOrdersAsReturnedFromStore_args:
13513 
  """
13514 
  Attributes:
13515 
   - providerId
13516 
   - orderIds
5713 rajveer 13517 
   - awbs
5676 rajveer 13518 
  """
13519 
 
13520 
  thrift_spec = (
13521 
    None, # 0
13522 
    (1, TType.I64, 'providerId', None, None, ), # 1
13523 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13524 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13525 
  )
13526 
 
5713 rajveer 13527 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13528 
    self.providerId = providerId
13529 
    self.orderIds = orderIds
5713 rajveer 13530 
    self.awbs = awbs
5676 rajveer 13531 
 
13532 
  def read(self, iprot):
13533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13535 
      return
13536 
    iprot.readStructBegin()
13537 
    while True:
13538 
      (fname, ftype, fid) = iprot.readFieldBegin()
13539 
      if ftype == TType.STOP:
13540 
        break
13541 
      if fid == 1:
13542 
        if ftype == TType.I64:
13543 
          self.providerId = iprot.readI64();
13544 
        else:
13545 
          iprot.skip(ftype)
13546 
      elif fid == 2:
13547 
        if ftype == TType.LIST:
13548 
          self.orderIds = []
6031 rajveer 13549 
          (_etype248, _size245) = iprot.readListBegin()
13550 
          for _i249 in xrange(_size245):
13551 
            _elem250 = iprot.readI64();
13552 
            self.orderIds.append(_elem250)
5676 rajveer 13553 
          iprot.readListEnd()
13554 
        else:
13555 
          iprot.skip(ftype)
5713 rajveer 13556 
      elif fid == 3:
13557 
        if ftype == TType.LIST:
13558 
          self.awbs = []
6031 rajveer 13559 
          (_etype254, _size251) = iprot.readListBegin()
13560 
          for _i255 in xrange(_size251):
13561 
            _elem256 = iprot.readString();
13562 
            self.awbs.append(_elem256)
5713 rajveer 13563 
          iprot.readListEnd()
13564 
        else:
13565 
          iprot.skip(ftype)
5676 rajveer 13566 
      else:
13567 
        iprot.skip(ftype)
13568 
      iprot.readFieldEnd()
13569 
    iprot.readStructEnd()
13570 
 
13571 
  def write(self, oprot):
13572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13574 
      return
13575 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13576 
    if self.providerId is not None:
13577 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13578 
      oprot.writeI64(self.providerId)
13579 
      oprot.writeFieldEnd()
13580 
    if self.orderIds is not None:
13581 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13582 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13583 
      for iter257 in self.orderIds:
13584 
        oprot.writeI64(iter257)
5676 rajveer 13585 
      oprot.writeListEnd()
13586 
      oprot.writeFieldEnd()
5713 rajveer 13587 
    if self.awbs is not None:
13588 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13589 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6031 rajveer 13590 
      for iter258 in self.awbs:
13591 
        oprot.writeString(iter258)
5713 rajveer 13592 
      oprot.writeListEnd()
13593 
      oprot.writeFieldEnd()
5676 rajveer 13594 
    oprot.writeFieldStop()
13595 
    oprot.writeStructEnd()
13596 
 
13597 
  def validate(self):
13598 
    return
13599 
 
13600 
 
13601 
  def __repr__(self):
13602 
    L = ['%s=%r' % (key, value)
13603 
      for key, value in self.__dict__.iteritems()]
13604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13605 
 
13606 
  def __eq__(self, other):
13607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13608 
 
13609 
  def __ne__(self, other):
13610 
    return not (self == other)
13611 
 
13612 
class markOrdersAsReturnedFromStore_result:
13613 
  """
13614 
  Attributes:
13615 
   - success
13616 
   - ex
13617 
  """
13618 
 
13619 
  thrift_spec = (
13620 
    (0, TType.BOOL, 'success', None, None, ), # 0
13621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13622 
  )
13623 
 
13624 
  def __init__(self, success=None, ex=None,):
13625 
    self.success = success
13626 
    self.ex = ex
13627 
 
13628 
  def read(self, iprot):
13629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13631 
      return
13632 
    iprot.readStructBegin()
13633 
    while True:
13634 
      (fname, ftype, fid) = iprot.readFieldBegin()
13635 
      if ftype == TType.STOP:
13636 
        break
13637 
      if fid == 0:
13638 
        if ftype == TType.BOOL:
13639 
          self.success = iprot.readBool();
13640 
        else:
13641 
          iprot.skip(ftype)
13642 
      elif fid == 1:
13643 
        if ftype == TType.STRUCT:
13644 
          self.ex = TransactionServiceException()
13645 
          self.ex.read(iprot)
13646 
        else:
13647 
          iprot.skip(ftype)
13648 
      else:
13649 
        iprot.skip(ftype)
13650 
      iprot.readFieldEnd()
13651 
    iprot.readStructEnd()
13652 
 
13653 
  def write(self, oprot):
13654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13656 
      return
13657 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13658 
    if self.success is not None:
13659 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13660 
      oprot.writeBool(self.success)
13661 
      oprot.writeFieldEnd()
13662 
    if self.ex is not None:
13663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13664 
      self.ex.write(oprot)
13665 
      oprot.writeFieldEnd()
13666 
    oprot.writeFieldStop()
13667 
    oprot.writeStructEnd()
13668 
 
13669 
  def validate(self):
13670 
    return
13671 
 
13672 
 
13673 
  def __repr__(self):
13674 
    L = ['%s=%r' % (key, value)
13675 
      for key, value in self.__dict__.iteritems()]
13676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13677 
 
13678 
  def __eq__(self, other):
13679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13680 
 
13681 
  def __ne__(self, other):
13682 
    return not (self == other)
13683 
 
4910 phani.kuma 13684 
class markOrdersAsPickedUp_args:
4410 rajveer 13685 
  """
13686 
  Attributes:
13687 
   - providerId
4910 phani.kuma 13688 
   - pickupDetails
4410 rajveer 13689 
  """
13690 
 
13691 
  thrift_spec = (
13692 
    None, # 0
4910 phani.kuma 13693 
    (1, TType.I64, 'providerId', None, None, ), # 1
13694 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13695 
  )
13696 
 
4910 phani.kuma 13697 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13698 
    self.providerId = providerId
4910 phani.kuma 13699 
    self.pickupDetails = pickupDetails
4410 rajveer 13700 
 
13701 
  def read(self, iprot):
13702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13704 
      return
13705 
    iprot.readStructBegin()
13706 
    while True:
13707 
      (fname, ftype, fid) = iprot.readFieldBegin()
13708 
      if ftype == TType.STOP:
13709 
        break
13710 
      if fid == 1:
13711 
        if ftype == TType.I64:
4910 phani.kuma 13712 
          self.providerId = iprot.readI64();
4410 rajveer 13713 
        else:
13714 
          iprot.skip(ftype)
13715 
      elif fid == 2:
4910 phani.kuma 13716 
        if ftype == TType.MAP:
13717 
          self.pickupDetails = {}
6031 rajveer 13718 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
13719 
          for _i263 in xrange(_size259):
13720 
            _key264 = iprot.readString();
13721 
            _val265 = iprot.readString();
13722 
            self.pickupDetails[_key264] = _val265
4910 phani.kuma 13723 
          iprot.readMapEnd()
4410 rajveer 13724 
        else:
13725 
          iprot.skip(ftype)
13726 
      else:
13727 
        iprot.skip(ftype)
13728 
      iprot.readFieldEnd()
13729 
    iprot.readStructEnd()
13730 
 
13731 
  def write(self, oprot):
13732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13734 
      return
4910 phani.kuma 13735 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13736 
    if self.providerId is not None:
4910 phani.kuma 13737 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13738 
      oprot.writeI64(self.providerId)
13739 
      oprot.writeFieldEnd()
4910 phani.kuma 13740 
    if self.pickupDetails is not None:
13741 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13742 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 13743 
      for kiter266,viter267 in self.pickupDetails.items():
13744 
        oprot.writeString(kiter266)
13745 
        oprot.writeString(viter267)
4910 phani.kuma 13746 
      oprot.writeMapEnd()
4410 rajveer 13747 
      oprot.writeFieldEnd()
13748 
    oprot.writeFieldStop()
13749 
    oprot.writeStructEnd()
13750 
 
13751 
  def validate(self):
13752 
    return
13753 
 
13754 
 
13755 
  def __repr__(self):
13756 
    L = ['%s=%r' % (key, value)
13757 
      for key, value in self.__dict__.iteritems()]
13758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13759 
 
13760 
  def __eq__(self, other):
13761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13762 
 
13763 
  def __ne__(self, other):
13764 
    return not (self == other)
13765 
 
4910 phani.kuma 13766 
class markOrdersAsPickedUp_result:
4410 rajveer 13767 
  """
13768 
  Attributes:
13769 
   - ex
13770 
  """
13771 
 
13772 
  thrift_spec = (
4910 phani.kuma 13773 
    None, # 0
4410 rajveer 13774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13775 
  )
13776 
 
4910 phani.kuma 13777 
  def __init__(self, ex=None,):
4410 rajveer 13778 
    self.ex = ex
13779 
 
13780 
  def read(self, iprot):
13781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13783 
      return
13784 
    iprot.readStructBegin()
13785 
    while True:
13786 
      (fname, ftype, fid) = iprot.readFieldBegin()
13787 
      if ftype == TType.STOP:
13788 
        break
4910 phani.kuma 13789 
      if fid == 1:
4410 rajveer 13790 
        if ftype == TType.STRUCT:
13791 
          self.ex = TransactionServiceException()
13792 
          self.ex.read(iprot)
13793 
        else:
13794 
          iprot.skip(ftype)
13795 
      else:
13796 
        iprot.skip(ftype)
13797 
      iprot.readFieldEnd()
13798 
    iprot.readStructEnd()
13799 
 
13800 
  def write(self, oprot):
13801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13803 
      return
4910 phani.kuma 13804 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13805 
    if self.ex is not None:
13806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13807 
      self.ex.write(oprot)
13808 
      oprot.writeFieldEnd()
13809 
    oprot.writeFieldStop()
13810 
    oprot.writeStructEnd()
13811 
 
13812 
  def validate(self):
13813 
    return
13814 
 
13815 
 
13816 
  def __repr__(self):
13817 
    L = ['%s=%r' % (key, value)
13818 
      for key, value in self.__dict__.iteritems()]
13819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13820 
 
13821 
  def __eq__(self, other):
13822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13823 
 
13824 
  def __ne__(self, other):
13825 
    return not (self == other)
13826 
 
4910 phani.kuma 13827 
class getOrdersNotPickedUp_args:
304 ashish 13828 
  """
13829 
  Attributes:
3064 chandransh 13830 
   - providerId
304 ashish 13831 
  """
94 ashish 13832 
 
304 ashish 13833 
  thrift_spec = (
13834 
    None, # 0
3064 chandransh 13835 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13836 
  )
13837 
 
4910 phani.kuma 13838 
  def __init__(self, providerId=None,):
3064 chandransh 13839 
    self.providerId = providerId
304 ashish 13840 
 
13841 
  def read(self, iprot):
13842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13844 
      return
13845 
    iprot.readStructBegin()
13846 
    while True:
13847 
      (fname, ftype, fid) = iprot.readFieldBegin()
13848 
      if ftype == TType.STOP:
13849 
        break
13850 
      if fid == 1:
13851 
        if ftype == TType.I64:
3064 chandransh 13852 
          self.providerId = iprot.readI64();
304 ashish 13853 
        else:
13854 
          iprot.skip(ftype)
13855 
      else:
13856 
        iprot.skip(ftype)
13857 
      iprot.readFieldEnd()
13858 
    iprot.readStructEnd()
13859 
 
13860 
  def write(self, oprot):
13861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13863 
      return
4910 phani.kuma 13864 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 13865 
    if self.providerId is not None:
3064 chandransh 13866 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13867 
      oprot.writeI64(self.providerId)
304 ashish 13868 
      oprot.writeFieldEnd()
13869 
    oprot.writeFieldStop()
13870 
    oprot.writeStructEnd()
13871 
 
3431 rajveer 13872 
  def validate(self):
13873 
    return
13874 
 
13875 
 
304 ashish 13876 
  def __repr__(self):
13877 
    L = ['%s=%r' % (key, value)
13878 
      for key, value in self.__dict__.iteritems()]
13879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13880 
 
13881 
  def __eq__(self, other):
13882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13883 
 
13884 
  def __ne__(self, other):
13885 
    return not (self == other)
13886 
 
4910 phani.kuma 13887 
class getOrdersNotPickedUp_result:
304 ashish 13888 
  """
13889 
  Attributes:
13890 
   - success
13891 
  """
13892 
 
13893 
  thrift_spec = (
3064 chandransh 13894 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 13895 
  )
13896 
 
4910 phani.kuma 13897 
  def __init__(self, success=None,):
304 ashish 13898 
    self.success = success
13899 
 
13900 
  def read(self, iprot):
13901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13903 
      return
13904 
    iprot.readStructBegin()
13905 
    while True:
13906 
      (fname, ftype, fid) = iprot.readFieldBegin()
13907 
      if ftype == TType.STOP:
13908 
        break
13909 
      if fid == 0:
13910 
        if ftype == TType.LIST:
13911 
          self.success = []
6031 rajveer 13912 
          (_etype271, _size268) = iprot.readListBegin()
13913 
          for _i272 in xrange(_size268):
13914 
            _elem273 = Order()
13915 
            _elem273.read(iprot)
13916 
            self.success.append(_elem273)
304 ashish 13917 
          iprot.readListEnd()
13918 
        else:
13919 
          iprot.skip(ftype)
13920 
      else:
13921 
        iprot.skip(ftype)
13922 
      iprot.readFieldEnd()
13923 
    iprot.readStructEnd()
13924 
 
13925 
  def write(self, oprot):
13926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13928 
      return
4910 phani.kuma 13929 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 13930 
    if self.success is not None:
304 ashish 13931 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13932 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 13933 
      for iter274 in self.success:
13934 
        iter274.write(oprot)
304 ashish 13935 
      oprot.writeListEnd()
13936 
      oprot.writeFieldEnd()
13937 
    oprot.writeFieldStop()
13938 
    oprot.writeStructEnd()
13939 
 
3431 rajveer 13940 
  def validate(self):
13941 
    return
13942 
 
13943 
 
304 ashish 13944 
  def __repr__(self):
13945 
    L = ['%s=%r' % (key, value)
13946 
      for key, value in self.__dict__.iteritems()]
13947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13948 
 
13949 
  def __eq__(self, other):
13950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13951 
 
13952 
  def __ne__(self, other):
13953 
    return not (self == other)
13954 
 
3064 chandransh 13955 
class markOrdersAsDelivered_args:
304 ashish 13956 
  """
13957 
  Attributes:
3064 chandransh 13958 
   - providerId
13959 
   - deliveredOrders
304 ashish 13960 
  """
13961 
 
13962 
  thrift_spec = (
13963 
    None, # 0
3064 chandransh 13964 
    (1, TType.I64, 'providerId', None, None, ), # 1
13965 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 13966 
  )
13967 
 
3064 chandransh 13968 
  def __init__(self, providerId=None, deliveredOrders=None,):
13969 
    self.providerId = providerId
13970 
    self.deliveredOrders = deliveredOrders
304 ashish 13971 
 
13972 
  def read(self, iprot):
13973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13975 
      return
13976 
    iprot.readStructBegin()
13977 
    while True:
13978 
      (fname, ftype, fid) = iprot.readFieldBegin()
13979 
      if ftype == TType.STOP:
13980 
        break
13981 
      if fid == 1:
13982 
        if ftype == TType.I64:
3064 chandransh 13983 
          self.providerId = iprot.readI64();
304 ashish 13984 
        else:
13985 
          iprot.skip(ftype)
13986 
      elif fid == 2:
3064 chandransh 13987 
        if ftype == TType.MAP:
13988 
          self.deliveredOrders = {}
6031 rajveer 13989 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
13990 
          for _i279 in xrange(_size275):
13991 
            _key280 = iprot.readString();
13992 
            _val281 = iprot.readString();
13993 
            self.deliveredOrders[_key280] = _val281
3064 chandransh 13994 
          iprot.readMapEnd()
304 ashish 13995 
        else:
13996 
          iprot.skip(ftype)
13997 
      else:
13998 
        iprot.skip(ftype)
13999 
      iprot.readFieldEnd()
14000 
    iprot.readStructEnd()
14001 
 
14002 
  def write(self, oprot):
14003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14005 
      return
3064 chandransh 14006 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14007 
    if self.providerId is not None:
3064 chandransh 14008 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14009 
      oprot.writeI64(self.providerId)
304 ashish 14010 
      oprot.writeFieldEnd()
3431 rajveer 14011 
    if self.deliveredOrders is not None:
3064 chandransh 14012 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14013 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6031 rajveer 14014 
      for kiter282,viter283 in self.deliveredOrders.items():
14015 
        oprot.writeString(kiter282)
14016 
        oprot.writeString(viter283)
3064 chandransh 14017 
      oprot.writeMapEnd()
304 ashish 14018 
      oprot.writeFieldEnd()
14019 
    oprot.writeFieldStop()
14020 
    oprot.writeStructEnd()
14021 
 
3431 rajveer 14022 
  def validate(self):
14023 
    return
14024 
 
14025 
 
304 ashish 14026 
  def __repr__(self):
14027 
    L = ['%s=%r' % (key, value)
14028 
      for key, value in self.__dict__.iteritems()]
14029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14030 
 
14031 
  def __eq__(self, other):
14032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14033 
 
14034 
  def __ne__(self, other):
14035 
    return not (self == other)
14036 
 
3064 chandransh 14037 
class markOrdersAsDelivered_result:
14038 
  """
14039 
  Attributes:
14040 
   - ex
14041 
  """
304 ashish 14042 
 
14043 
  thrift_spec = (
3064 chandransh 14044 
    None, # 0
14045 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14046 
  )
14047 
 
3064 chandransh 14048 
  def __init__(self, ex=None,):
14049 
    self.ex = ex
304 ashish 14050 
 
1596 ankur.sing 14051 
  def read(self, iprot):
14052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14054 
      return
14055 
    iprot.readStructBegin()
14056 
    while True:
14057 
      (fname, ftype, fid) = iprot.readFieldBegin()
14058 
      if ftype == TType.STOP:
14059 
        break
3064 chandransh 14060 
      if fid == 1:
14061 
        if ftype == TType.STRUCT:
14062 
          self.ex = TransactionServiceException()
14063 
          self.ex.read(iprot)
14064 
        else:
14065 
          iprot.skip(ftype)
1596 ankur.sing 14066 
      else:
14067 
        iprot.skip(ftype)
14068 
      iprot.readFieldEnd()
14069 
    iprot.readStructEnd()
14070 
 
14071 
  def write(self, oprot):
14072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14074 
      return
3064 chandransh 14075 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14076 
    if self.ex is not None:
3064 chandransh 14077 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14078 
      self.ex.write(oprot)
14079 
      oprot.writeFieldEnd()
1596 ankur.sing 14080 
    oprot.writeFieldStop()
14081 
    oprot.writeStructEnd()
14082 
 
3431 rajveer 14083 
  def validate(self):
14084 
    return
14085 
 
14086 
 
1596 ankur.sing 14087 
  def __repr__(self):
14088 
    L = ['%s=%r' % (key, value)
14089 
      for key, value in self.__dict__.iteritems()]
14090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14091 
 
14092 
  def __eq__(self, other):
14093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14094 
 
14095 
  def __ne__(self, other):
14096 
    return not (self == other)
14097 
 
4910 phani.kuma 14098 
class markAsRTOrders_args:
1596 ankur.sing 14099 
  """
14100 
  Attributes:
3064 chandransh 14101 
   - providerId
14102 
   - returnedOrders
1596 ankur.sing 14103 
  """
14104 
 
14105 
  thrift_spec = (
3064 chandransh 14106 
    None, # 0
14107 
    (1, TType.I64, 'providerId', None, None, ), # 1
14108 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14109 
  )
14110 
 
3064 chandransh 14111 
  def __init__(self, providerId=None, returnedOrders=None,):
14112 
    self.providerId = providerId
14113 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14114 
 
14115 
  def read(self, iprot):
14116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14118 
      return
14119 
    iprot.readStructBegin()
14120 
    while True:
14121 
      (fname, ftype, fid) = iprot.readFieldBegin()
14122 
      if ftype == TType.STOP:
14123 
        break
3064 chandransh 14124 
      if fid == 1:
1596 ankur.sing 14125 
        if ftype == TType.I64:
3064 chandransh 14126 
          self.providerId = iprot.readI64();
1596 ankur.sing 14127 
        else:
14128 
          iprot.skip(ftype)
3064 chandransh 14129 
      elif fid == 2:
14130 
        if ftype == TType.MAP:
14131 
          self.returnedOrders = {}
6031 rajveer 14132 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
14133 
          for _i288 in xrange(_size284):
14134 
            _key289 = iprot.readString();
14135 
            _val290 = iprot.readString();
14136 
            self.returnedOrders[_key289] = _val290
3064 chandransh 14137 
          iprot.readMapEnd()
14138 
        else:
14139 
          iprot.skip(ftype)
1596 ankur.sing 14140 
      else:
14141 
        iprot.skip(ftype)
14142 
      iprot.readFieldEnd()
14143 
    iprot.readStructEnd()
14144 
 
14145 
  def write(self, oprot):
14146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14148 
      return
4910 phani.kuma 14149 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14150 
    if self.providerId is not None:
3064 chandransh 14151 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14152 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14153 
      oprot.writeFieldEnd()
3431 rajveer 14154 
    if self.returnedOrders is not None:
3064 chandransh 14155 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14156 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6031 rajveer 14157 
      for kiter291,viter292 in self.returnedOrders.items():
14158 
        oprot.writeString(kiter291)
14159 
        oprot.writeString(viter292)
3064 chandransh 14160 
      oprot.writeMapEnd()
14161 
      oprot.writeFieldEnd()
1596 ankur.sing 14162 
    oprot.writeFieldStop()
14163 
    oprot.writeStructEnd()
14164 
 
3431 rajveer 14165 
  def validate(self):
14166 
    return
14167 
 
14168 
 
1596 ankur.sing 14169 
  def __repr__(self):
14170 
    L = ['%s=%r' % (key, value)
14171 
      for key, value in self.__dict__.iteritems()]
14172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14173 
 
14174 
  def __eq__(self, other):
14175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14176 
 
14177 
  def __ne__(self, other):
14178 
    return not (self == other)
14179 
 
4910 phani.kuma 14180 
class markAsRTOrders_result:
3064 chandransh 14181 
  """
14182 
  Attributes:
14183 
   - ex
14184 
  """
1596 ankur.sing 14185 
 
1627 ankur.sing 14186 
  thrift_spec = (
3064 chandransh 14187 
    None, # 0
14188 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14189 
  )
14190 
 
3064 chandransh 14191 
  def __init__(self, ex=None,):
14192 
    self.ex = ex
14193 
 
1627 ankur.sing 14194 
  def read(self, iprot):
14195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14197 
      return
14198 
    iprot.readStructBegin()
14199 
    while True:
14200 
      (fname, ftype, fid) = iprot.readFieldBegin()
14201 
      if ftype == TType.STOP:
14202 
        break
3064 chandransh 14203 
      if fid == 1:
14204 
        if ftype == TType.STRUCT:
14205 
          self.ex = TransactionServiceException()
14206 
          self.ex.read(iprot)
14207 
        else:
14208 
          iprot.skip(ftype)
1627 ankur.sing 14209 
      else:
14210 
        iprot.skip(ftype)
14211 
      iprot.readFieldEnd()
14212 
    iprot.readStructEnd()
14213 
 
14214 
  def write(self, oprot):
14215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14217 
      return
4910 phani.kuma 14218 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14219 
    if self.ex is not None:
3064 chandransh 14220 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14221 
      self.ex.write(oprot)
14222 
      oprot.writeFieldEnd()
1627 ankur.sing 14223 
    oprot.writeFieldStop()
14224 
    oprot.writeStructEnd()
14225 
 
3431 rajveer 14226 
  def validate(self):
14227 
    return
14228 
 
14229 
 
1627 ankur.sing 14230 
  def __repr__(self):
14231 
    L = ['%s=%r' % (key, value)
14232 
      for key, value in self.__dict__.iteritems()]
14233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14234 
 
14235 
  def __eq__(self, other):
14236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14237 
 
14238 
  def __ne__(self, other):
14239 
    return not (self == other)
14240 
 
4910 phani.kuma 14241 
class getRTOrders_args:
14242 
  """
14243 
  Attributes:
14244 
   - providerId
14245 
  """
14246 
 
14247 
  thrift_spec = (
14248 
    None, # 0
14249 
    (1, TType.I64, 'providerId', None, None, ), # 1
14250 
  )
14251 
 
14252 
  def __init__(self, providerId=None,):
14253 
    self.providerId = providerId
14254 
 
14255 
  def read(self, iprot):
14256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14258 
      return
14259 
    iprot.readStructBegin()
14260 
    while True:
14261 
      (fname, ftype, fid) = iprot.readFieldBegin()
14262 
      if ftype == TType.STOP:
14263 
        break
14264 
      if fid == 1:
14265 
        if ftype == TType.I64:
14266 
          self.providerId = iprot.readI64();
14267 
        else:
14268 
          iprot.skip(ftype)
14269 
      else:
14270 
        iprot.skip(ftype)
14271 
      iprot.readFieldEnd()
14272 
    iprot.readStructEnd()
14273 
 
14274 
  def write(self, oprot):
14275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14277 
      return
14278 
    oprot.writeStructBegin('getRTOrders_args')
14279 
    if self.providerId is not None:
14280 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14281 
      oprot.writeI64(self.providerId)
14282 
      oprot.writeFieldEnd()
14283 
    oprot.writeFieldStop()
14284 
    oprot.writeStructEnd()
14285 
 
14286 
  def validate(self):
14287 
    return
14288 
 
14289 
 
14290 
  def __repr__(self):
14291 
    L = ['%s=%r' % (key, value)
14292 
      for key, value in self.__dict__.iteritems()]
14293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14294 
 
14295 
  def __eq__(self, other):
14296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14297 
 
14298 
  def __ne__(self, other):
14299 
    return not (self == other)
14300 
 
14301 
class getRTOrders_result:
14302 
  """
14303 
  Attributes:
14304 
   - success
14305 
  """
14306 
 
14307 
  thrift_spec = (
14308 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14309 
  )
14310 
 
14311 
  def __init__(self, success=None,):
14312 
    self.success = success
14313 
 
14314 
  def read(self, iprot):
14315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14317 
      return
14318 
    iprot.readStructBegin()
14319 
    while True:
14320 
      (fname, ftype, fid) = iprot.readFieldBegin()
14321 
      if ftype == TType.STOP:
14322 
        break
14323 
      if fid == 0:
14324 
        if ftype == TType.LIST:
14325 
          self.success = []
6031 rajveer 14326 
          (_etype296, _size293) = iprot.readListBegin()
14327 
          for _i297 in xrange(_size293):
14328 
            _elem298 = Order()
14329 
            _elem298.read(iprot)
14330 
            self.success.append(_elem298)
4910 phani.kuma 14331 
          iprot.readListEnd()
14332 
        else:
14333 
          iprot.skip(ftype)
14334 
      else:
14335 
        iprot.skip(ftype)
14336 
      iprot.readFieldEnd()
14337 
    iprot.readStructEnd()
14338 
 
14339 
  def write(self, oprot):
14340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14342 
      return
14343 
    oprot.writeStructBegin('getRTOrders_result')
14344 
    if self.success is not None:
14345 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14346 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14347 
      for iter299 in self.success:
14348 
        iter299.write(oprot)
4910 phani.kuma 14349 
      oprot.writeListEnd()
14350 
      oprot.writeFieldEnd()
14351 
    oprot.writeFieldStop()
14352 
    oprot.writeStructEnd()
14353 
 
14354 
  def validate(self):
14355 
    return
14356 
 
14357 
 
14358 
  def __repr__(self):
14359 
    L = ['%s=%r' % (key, value)
14360 
      for key, value in self.__dict__.iteritems()]
14361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14362 
 
14363 
  def __eq__(self, other):
14364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14365 
 
14366 
  def __ne__(self, other):
14367 
    return not (self == other)
14368 
 
3064 chandransh 14369 
class updateNonDeliveryReason_args:
1627 ankur.sing 14370 
  """
14371 
  Attributes:
3064 chandransh 14372 
   - providerId
14373 
   - undeliveredOrders
1627 ankur.sing 14374 
  """
14375 
 
14376 
  thrift_spec = (
3064 chandransh 14377 
    None, # 0
14378 
    (1, TType.I64, 'providerId', None, None, ), # 1
14379 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14380 
  )
14381 
 
3064 chandransh 14382 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14383 
    self.providerId = providerId
14384 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14385 
 
14386 
  def read(self, iprot):
14387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14389 
      return
14390 
    iprot.readStructBegin()
14391 
    while True:
14392 
      (fname, ftype, fid) = iprot.readFieldBegin()
14393 
      if ftype == TType.STOP:
14394 
        break
3064 chandransh 14395 
      if fid == 1:
1627 ankur.sing 14396 
        if ftype == TType.I64:
3064 chandransh 14397 
          self.providerId = iprot.readI64();
1627 ankur.sing 14398 
        else:
14399 
          iprot.skip(ftype)
3064 chandransh 14400 
      elif fid == 2:
14401 
        if ftype == TType.MAP:
14402 
          self.undeliveredOrders = {}
6031 rajveer 14403 
          (_ktype301, _vtype302, _size300 ) = iprot.readMapBegin()
14404 
          for _i304 in xrange(_size300):
14405 
            _key305 = iprot.readString();
14406 
            _val306 = iprot.readString();
14407 
            self.undeliveredOrders[_key305] = _val306
3064 chandransh 14408 
          iprot.readMapEnd()
14409 
        else:
14410 
          iprot.skip(ftype)
1627 ankur.sing 14411 
      else:
14412 
        iprot.skip(ftype)
14413 
      iprot.readFieldEnd()
14414 
    iprot.readStructEnd()
14415 
 
14416 
  def write(self, oprot):
14417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14419 
      return
3064 chandransh 14420 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14421 
    if self.providerId is not None:
3064 chandransh 14422 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14423 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14424 
      oprot.writeFieldEnd()
3431 rajveer 14425 
    if self.undeliveredOrders is not None:
3064 chandransh 14426 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14427 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6031 rajveer 14428 
      for kiter307,viter308 in self.undeliveredOrders.items():
14429 
        oprot.writeString(kiter307)
14430 
        oprot.writeString(viter308)
3064 chandransh 14431 
      oprot.writeMapEnd()
14432 
      oprot.writeFieldEnd()
1627 ankur.sing 14433 
    oprot.writeFieldStop()
14434 
    oprot.writeStructEnd()
14435 
 
3431 rajveer 14436 
  def validate(self):
14437 
    return
14438 
 
14439 
 
1627 ankur.sing 14440 
  def __repr__(self):
14441 
    L = ['%s=%r' % (key, value)
14442 
      for key, value in self.__dict__.iteritems()]
14443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14444 
 
14445 
  def __eq__(self, other):
14446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14447 
 
14448 
  def __ne__(self, other):
14449 
    return not (self == other)
14450 
 
3064 chandransh 14451 
class updateNonDeliveryReason_result:
1627 ankur.sing 14452 
  """
14453 
  Attributes:
3064 chandransh 14454 
   - ex
1627 ankur.sing 14455 
  """
14456 
 
14457 
  thrift_spec = (
4910 phani.kuma 14458 
    None, # 0
3064 chandransh 14459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14460 
  )
14461 
 
4910 phani.kuma 14462 
  def __init__(self, ex=None,):
3064 chandransh 14463 
    self.ex = ex
1627 ankur.sing 14464 
 
14465 
  def read(self, iprot):
14466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14468 
      return
14469 
    iprot.readStructBegin()
14470 
    while True:
14471 
      (fname, ftype, fid) = iprot.readFieldBegin()
14472 
      if ftype == TType.STOP:
14473 
        break
4910 phani.kuma 14474 
      if fid == 1:
14475 
        if ftype == TType.STRUCT:
14476 
          self.ex = TransactionServiceException()
14477 
          self.ex.read(iprot)
14478 
        else:
14479 
          iprot.skip(ftype)
14480 
      else:
14481 
        iprot.skip(ftype)
14482 
      iprot.readFieldEnd()
14483 
    iprot.readStructEnd()
14484 
 
14485 
  def write(self, oprot):
14486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14488 
      return
14489 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14490 
    if self.ex is not None:
14491 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14492 
      self.ex.write(oprot)
14493 
      oprot.writeFieldEnd()
14494 
    oprot.writeFieldStop()
14495 
    oprot.writeStructEnd()
14496 
 
14497 
  def validate(self):
14498 
    return
14499 
 
14500 
 
14501 
  def __repr__(self):
14502 
    L = ['%s=%r' % (key, value)
14503 
      for key, value in self.__dict__.iteritems()]
14504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14505 
 
14506 
  def __eq__(self, other):
14507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14508 
 
14509 
  def __ne__(self, other):
14510 
    return not (self == other)
14511 
 
14512 
class getNonDeliveredOrdersbyCourier_args:
14513 
  """
14514 
  Attributes:
14515 
   - providerId
14516 
  """
14517 
 
14518 
  thrift_spec = (
14519 
    None, # 0
14520 
    (1, TType.I64, 'providerId', None, None, ), # 1
14521 
  )
14522 
 
14523 
  def __init__(self, providerId=None,):
14524 
    self.providerId = providerId
14525 
 
14526 
  def read(self, iprot):
14527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14529 
      return
14530 
    iprot.readStructBegin()
14531 
    while True:
14532 
      (fname, ftype, fid) = iprot.readFieldBegin()
14533 
      if ftype == TType.STOP:
14534 
        break
14535 
      if fid == 1:
14536 
        if ftype == TType.I64:
14537 
          self.providerId = iprot.readI64();
14538 
        else:
14539 
          iprot.skip(ftype)
14540 
      else:
14541 
        iprot.skip(ftype)
14542 
      iprot.readFieldEnd()
14543 
    iprot.readStructEnd()
14544 
 
14545 
  def write(self, oprot):
14546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14548 
      return
14549 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14550 
    if self.providerId is not None:
14551 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14552 
      oprot.writeI64(self.providerId)
14553 
      oprot.writeFieldEnd()
14554 
    oprot.writeFieldStop()
14555 
    oprot.writeStructEnd()
14556 
 
14557 
  def validate(self):
14558 
    return
14559 
 
14560 
 
14561 
  def __repr__(self):
14562 
    L = ['%s=%r' % (key, value)
14563 
      for key, value in self.__dict__.iteritems()]
14564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14565 
 
14566 
  def __eq__(self, other):
14567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14568 
 
14569 
  def __ne__(self, other):
14570 
    return not (self == other)
14571 
 
14572 
class getNonDeliveredOrdersbyCourier_result:
14573 
  """
14574 
  Attributes:
14575 
   - success
14576 
  """
14577 
 
14578 
  thrift_spec = (
14579 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14580 
  )
14581 
 
14582 
  def __init__(self, success=None,):
14583 
    self.success = success
14584 
 
14585 
  def read(self, iprot):
14586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14588 
      return
14589 
    iprot.readStructBegin()
14590 
    while True:
14591 
      (fname, ftype, fid) = iprot.readFieldBegin()
14592 
      if ftype == TType.STOP:
14593 
        break
4581 phani.kuma 14594 
      if fid == 0:
14595 
        if ftype == TType.LIST:
14596 
          self.success = []
6031 rajveer 14597 
          (_etype312, _size309) = iprot.readListBegin()
14598 
          for _i313 in xrange(_size309):
14599 
            _elem314 = Order()
14600 
            _elem314.read(iprot)
14601 
            self.success.append(_elem314)
4581 phani.kuma 14602 
          iprot.readListEnd()
14603 
        else:
14604 
          iprot.skip(ftype)
4910 phani.kuma 14605 
      else:
14606 
        iprot.skip(ftype)
14607 
      iprot.readFieldEnd()
14608 
    iprot.readStructEnd()
14609 
 
14610 
  def write(self, oprot):
14611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14613 
      return
14614 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14615 
    if self.success is not None:
14616 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14617 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14618 
      for iter315 in self.success:
14619 
        iter315.write(oprot)
4910 phani.kuma 14620 
      oprot.writeListEnd()
14621 
      oprot.writeFieldEnd()
14622 
    oprot.writeFieldStop()
14623 
    oprot.writeStructEnd()
14624 
 
14625 
  def validate(self):
14626 
    return
14627 
 
14628 
 
14629 
  def __repr__(self):
14630 
    L = ['%s=%r' % (key, value)
14631 
      for key, value in self.__dict__.iteritems()]
14632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14633 
 
14634 
  def __eq__(self, other):
14635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14636 
 
14637 
  def __ne__(self, other):
14638 
    return not (self == other)
14639 
 
14640 
class markOrdersAsLocalConnected_args:
14641 
  """
14642 
  Attributes:
14643 
   - providerId
14644 
   - local_connected_orders
14645 
  """
14646 
 
14647 
  thrift_spec = (
14648 
    None, # 0
14649 
    (1, TType.I64, 'providerId', None, None, ), # 1
14650 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14651 
  )
14652 
 
14653 
  def __init__(self, providerId=None, local_connected_orders=None,):
14654 
    self.providerId = providerId
14655 
    self.local_connected_orders = local_connected_orders
14656 
 
14657 
  def read(self, iprot):
14658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14660 
      return
14661 
    iprot.readStructBegin()
14662 
    while True:
14663 
      (fname, ftype, fid) = iprot.readFieldBegin()
14664 
      if ftype == TType.STOP:
14665 
        break
14666 
      if fid == 1:
14667 
        if ftype == TType.I64:
14668 
          self.providerId = iprot.readI64();
14669 
        else:
14670 
          iprot.skip(ftype)
14671 
      elif fid == 2:
14672 
        if ftype == TType.MAP:
14673 
          self.local_connected_orders = {}
6031 rajveer 14674 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14675 
          for _i320 in xrange(_size316):
14676 
            _key321 = iprot.readString();
14677 
            _val322 = iprot.readString();
14678 
            self.local_connected_orders[_key321] = _val322
4910 phani.kuma 14679 
          iprot.readMapEnd()
14680 
        else:
14681 
          iprot.skip(ftype)
14682 
      else:
14683 
        iprot.skip(ftype)
14684 
      iprot.readFieldEnd()
14685 
    iprot.readStructEnd()
14686 
 
14687 
  def write(self, oprot):
14688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14690 
      return
14691 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14692 
    if self.providerId is not None:
14693 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14694 
      oprot.writeI64(self.providerId)
14695 
      oprot.writeFieldEnd()
14696 
    if self.local_connected_orders is not None:
14697 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14698 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6031 rajveer 14699 
      for kiter323,viter324 in self.local_connected_orders.items():
14700 
        oprot.writeString(kiter323)
14701 
        oprot.writeString(viter324)
4910 phani.kuma 14702 
      oprot.writeMapEnd()
14703 
      oprot.writeFieldEnd()
14704 
    oprot.writeFieldStop()
14705 
    oprot.writeStructEnd()
14706 
 
14707 
  def validate(self):
14708 
    return
14709 
 
14710 
 
14711 
  def __repr__(self):
14712 
    L = ['%s=%r' % (key, value)
14713 
      for key, value in self.__dict__.iteritems()]
14714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14715 
 
14716 
  def __eq__(self, other):
14717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14718 
 
14719 
  def __ne__(self, other):
14720 
    return not (self == other)
14721 
 
14722 
class markOrdersAsLocalConnected_result:
14723 
  """
14724 
  Attributes:
14725 
   - ex
14726 
  """
14727 
 
14728 
  thrift_spec = (
14729 
    None, # 0
14730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14731 
  )
14732 
 
14733 
  def __init__(self, ex=None,):
14734 
    self.ex = ex
14735 
 
14736 
  def read(self, iprot):
14737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14739 
      return
14740 
    iprot.readStructBegin()
14741 
    while True:
14742 
      (fname, ftype, fid) = iprot.readFieldBegin()
14743 
      if ftype == TType.STOP:
14744 
        break
14745 
      if fid == 1:
3064 chandransh 14746 
        if ftype == TType.STRUCT:
14747 
          self.ex = TransactionServiceException()
14748 
          self.ex.read(iprot)
1627 ankur.sing 14749 
        else:
14750 
          iprot.skip(ftype)
14751 
      else:
14752 
        iprot.skip(ftype)
14753 
      iprot.readFieldEnd()
14754 
    iprot.readStructEnd()
14755 
 
14756 
  def write(self, oprot):
14757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14759 
      return
4910 phani.kuma 14760 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14761 
    if self.ex is not None:
14762 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14763 
      self.ex.write(oprot)
14764 
      oprot.writeFieldEnd()
14765 
    oprot.writeFieldStop()
14766 
    oprot.writeStructEnd()
14767 
 
14768 
  def validate(self):
14769 
    return
14770 
 
14771 
 
14772 
  def __repr__(self):
14773 
    L = ['%s=%r' % (key, value)
14774 
      for key, value in self.__dict__.iteritems()]
14775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14776 
 
14777 
  def __eq__(self, other):
14778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14779 
 
14780 
  def __ne__(self, other):
14781 
    return not (self == other)
14782 
 
14783 
class getOrdersNotLocalConnected_args:
14784 
  """
14785 
  Attributes:
14786 
   - providerId
14787 
  """
14788 
 
14789 
  thrift_spec = (
14790 
    None, # 0
14791 
    (1, TType.I64, 'providerId', None, None, ), # 1
14792 
  )
14793 
 
14794 
  def __init__(self, providerId=None,):
14795 
    self.providerId = providerId
14796 
 
14797 
  def read(self, iprot):
14798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14800 
      return
14801 
    iprot.readStructBegin()
14802 
    while True:
14803 
      (fname, ftype, fid) = iprot.readFieldBegin()
14804 
      if ftype == TType.STOP:
14805 
        break
14806 
      if fid == 1:
14807 
        if ftype == TType.I64:
14808 
          self.providerId = iprot.readI64();
14809 
        else:
14810 
          iprot.skip(ftype)
14811 
      else:
14812 
        iprot.skip(ftype)
14813 
      iprot.readFieldEnd()
14814 
    iprot.readStructEnd()
14815 
 
14816 
  def write(self, oprot):
14817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14819 
      return
14820 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14821 
    if self.providerId is not None:
14822 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14823 
      oprot.writeI64(self.providerId)
14824 
      oprot.writeFieldEnd()
14825 
    oprot.writeFieldStop()
14826 
    oprot.writeStructEnd()
14827 
 
14828 
  def validate(self):
14829 
    return
14830 
 
14831 
 
14832 
  def __repr__(self):
14833 
    L = ['%s=%r' % (key, value)
14834 
      for key, value in self.__dict__.iteritems()]
14835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14836 
 
14837 
  def __eq__(self, other):
14838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14839 
 
14840 
  def __ne__(self, other):
14841 
    return not (self == other)
14842 
 
14843 
class getOrdersNotLocalConnected_result:
14844 
  """
14845 
  Attributes:
14846 
   - success
14847 
  """
14848 
 
14849 
  thrift_spec = (
14850 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14851 
  )
14852 
 
14853 
  def __init__(self, success=None,):
14854 
    self.success = success
14855 
 
14856 
  def read(self, iprot):
14857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14859 
      return
14860 
    iprot.readStructBegin()
14861 
    while True:
14862 
      (fname, ftype, fid) = iprot.readFieldBegin()
14863 
      if ftype == TType.STOP:
14864 
        break
14865 
      if fid == 0:
14866 
        if ftype == TType.LIST:
14867 
          self.success = []
6031 rajveer 14868 
          (_etype328, _size325) = iprot.readListBegin()
14869 
          for _i329 in xrange(_size325):
14870 
            _elem330 = Order()
14871 
            _elem330.read(iprot)
14872 
            self.success.append(_elem330)
4910 phani.kuma 14873 
          iprot.readListEnd()
14874 
        else:
14875 
          iprot.skip(ftype)
14876 
      else:
14877 
        iprot.skip(ftype)
14878 
      iprot.readFieldEnd()
14879 
    iprot.readStructEnd()
14880 
 
14881 
  def write(self, oprot):
14882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14884 
      return
14885 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 14886 
    if self.success is not None:
14887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14888 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14889 
      for iter331 in self.success:
14890 
        iter331.write(oprot)
4581 phani.kuma 14891 
      oprot.writeListEnd()
14892 
      oprot.writeFieldEnd()
4910 phani.kuma 14893 
    oprot.writeFieldStop()
14894 
    oprot.writeStructEnd()
14895 
 
14896 
  def validate(self):
14897 
    return
14898 
 
14899 
 
14900 
  def __repr__(self):
14901 
    L = ['%s=%r' % (key, value)
14902 
      for key, value in self.__dict__.iteritems()]
14903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14904 
 
14905 
  def __eq__(self, other):
14906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14907 
 
14908 
  def __ne__(self, other):
14909 
    return not (self == other)
14910 
 
14911 
class markOrdersAsDestinationCityReached_args:
14912 
  """
14913 
  Attributes:
14914 
   - providerId
14915 
   - destination_city_reached_orders
14916 
  """
14917 
 
14918 
  thrift_spec = (
14919 
    None, # 0
14920 
    (1, TType.I64, 'providerId', None, None, ), # 1
14921 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14922 
  )
14923 
 
14924 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
14925 
    self.providerId = providerId
14926 
    self.destination_city_reached_orders = destination_city_reached_orders
14927 
 
14928 
  def read(self, iprot):
14929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14931 
      return
14932 
    iprot.readStructBegin()
14933 
    while True:
14934 
      (fname, ftype, fid) = iprot.readFieldBegin()
14935 
      if ftype == TType.STOP:
14936 
        break
14937 
      if fid == 1:
14938 
        if ftype == TType.I64:
14939 
          self.providerId = iprot.readI64();
14940 
        else:
14941 
          iprot.skip(ftype)
14942 
      elif fid == 2:
14943 
        if ftype == TType.MAP:
14944 
          self.destination_city_reached_orders = {}
6031 rajveer 14945 
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin()
14946 
          for _i336 in xrange(_size332):
14947 
            _key337 = iprot.readString();
14948 
            _val338 = iprot.readString();
14949 
            self.destination_city_reached_orders[_key337] = _val338
4910 phani.kuma 14950 
          iprot.readMapEnd()
14951 
        else:
14952 
          iprot.skip(ftype)
14953 
      else:
14954 
        iprot.skip(ftype)
14955 
      iprot.readFieldEnd()
14956 
    iprot.readStructEnd()
14957 
 
14958 
  def write(self, oprot):
14959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14961 
      return
14962 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
14963 
    if self.providerId is not None:
14964 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14965 
      oprot.writeI64(self.providerId)
14966 
      oprot.writeFieldEnd()
14967 
    if self.destination_city_reached_orders is not None:
14968 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
14969 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6031 rajveer 14970 
      for kiter339,viter340 in self.destination_city_reached_orders.items():
14971 
        oprot.writeString(kiter339)
14972 
        oprot.writeString(viter340)
4910 phani.kuma 14973 
      oprot.writeMapEnd()
14974 
      oprot.writeFieldEnd()
14975 
    oprot.writeFieldStop()
14976 
    oprot.writeStructEnd()
14977 
 
14978 
  def validate(self):
14979 
    return
14980 
 
14981 
 
14982 
  def __repr__(self):
14983 
    L = ['%s=%r' % (key, value)
14984 
      for key, value in self.__dict__.iteritems()]
14985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14986 
 
14987 
  def __eq__(self, other):
14988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14989 
 
14990 
  def __ne__(self, other):
14991 
    return not (self == other)
14992 
 
14993 
class markOrdersAsDestinationCityReached_result:
14994 
  """
14995 
  Attributes:
14996 
   - ex
14997 
  """
14998 
 
14999 
  thrift_spec = (
15000 
    None, # 0
15001 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15002 
  )
15003 
 
15004 
  def __init__(self, ex=None,):
15005 
    self.ex = ex
15006 
 
15007 
  def read(self, iprot):
15008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15010 
      return
15011 
    iprot.readStructBegin()
15012 
    while True:
15013 
      (fname, ftype, fid) = iprot.readFieldBegin()
15014 
      if ftype == TType.STOP:
15015 
        break
15016 
      if fid == 1:
15017 
        if ftype == TType.STRUCT:
15018 
          self.ex = TransactionServiceException()
15019 
          self.ex.read(iprot)
15020 
        else:
15021 
          iprot.skip(ftype)
15022 
      else:
15023 
        iprot.skip(ftype)
15024 
      iprot.readFieldEnd()
15025 
    iprot.readStructEnd()
15026 
 
15027 
  def write(self, oprot):
15028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15030 
      return
15031 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15032 
    if self.ex is not None:
3064 chandransh 15033 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15034 
      self.ex.write(oprot)
1627 ankur.sing 15035 
      oprot.writeFieldEnd()
15036 
    oprot.writeFieldStop()
15037 
    oprot.writeStructEnd()
15038 
 
3431 rajveer 15039 
  def validate(self):
15040 
    return
15041 
 
15042 
 
1627 ankur.sing 15043 
  def __repr__(self):
15044 
    L = ['%s=%r' % (key, value)
15045 
      for key, value in self.__dict__.iteritems()]
15046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15047 
 
15048 
  def __eq__(self, other):
15049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15050 
 
15051 
  def __ne__(self, other):
15052 
    return not (self == other)
15053 
 
4910 phani.kuma 15054 
class markOrdersAsFirstDeliveryAttempted_args:
15055 
  """
15056 
  Attributes:
15057 
   - providerId
15058 
   - first_atdl_orders
15059 
  """
15060 
 
15061 
  thrift_spec = (
15062 
    None, # 0
15063 
    (1, TType.I64, 'providerId', None, None, ), # 1
15064 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15065 
  )
15066 
 
15067 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15068 
    self.providerId = providerId
15069 
    self.first_atdl_orders = first_atdl_orders
15070 
 
15071 
  def read(self, iprot):
15072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15074 
      return
15075 
    iprot.readStructBegin()
15076 
    while True:
15077 
      (fname, ftype, fid) = iprot.readFieldBegin()
15078 
      if ftype == TType.STOP:
15079 
        break
15080 
      if fid == 1:
15081 
        if ftype == TType.I64:
15082 
          self.providerId = iprot.readI64();
15083 
        else:
15084 
          iprot.skip(ftype)
15085 
      elif fid == 2:
15086 
        if ftype == TType.MAP:
15087 
          self.first_atdl_orders = {}
6031 rajveer 15088 
          (_ktype342, _vtype343, _size341 ) = iprot.readMapBegin()
15089 
          for _i345 in xrange(_size341):
15090 
            _key346 = iprot.readString();
15091 
            _val347 = iprot.readString();
15092 
            self.first_atdl_orders[_key346] = _val347
4910 phani.kuma 15093 
          iprot.readMapEnd()
15094 
        else:
15095 
          iprot.skip(ftype)
15096 
      else:
15097 
        iprot.skip(ftype)
15098 
      iprot.readFieldEnd()
15099 
    iprot.readStructEnd()
15100 
 
15101 
  def write(self, oprot):
15102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15104 
      return
15105 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15106 
    if self.providerId is not None:
15107 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15108 
      oprot.writeI64(self.providerId)
15109 
      oprot.writeFieldEnd()
15110 
    if self.first_atdl_orders is not None:
15111 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15112 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6031 rajveer 15113 
      for kiter348,viter349 in self.first_atdl_orders.items():
15114 
        oprot.writeString(kiter348)
15115 
        oprot.writeString(viter349)
4910 phani.kuma 15116 
      oprot.writeMapEnd()
15117 
      oprot.writeFieldEnd()
15118 
    oprot.writeFieldStop()
15119 
    oprot.writeStructEnd()
15120 
 
15121 
  def validate(self):
15122 
    return
15123 
 
15124 
 
15125 
  def __repr__(self):
15126 
    L = ['%s=%r' % (key, value)
15127 
      for key, value in self.__dict__.iteritems()]
15128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15129 
 
15130 
  def __eq__(self, other):
15131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15132 
 
15133 
  def __ne__(self, other):
15134 
    return not (self == other)
15135 
 
15136 
class markOrdersAsFirstDeliveryAttempted_result:
15137 
  """
15138 
  Attributes:
15139 
   - ex
15140 
  """
15141 
 
15142 
  thrift_spec = (
15143 
    None, # 0
15144 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15145 
  )
15146 
 
15147 
  def __init__(self, ex=None,):
15148 
    self.ex = ex
15149 
 
15150 
  def read(self, iprot):
15151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15153 
      return
15154 
    iprot.readStructBegin()
15155 
    while True:
15156 
      (fname, ftype, fid) = iprot.readFieldBegin()
15157 
      if ftype == TType.STOP:
15158 
        break
15159 
      if fid == 1:
15160 
        if ftype == TType.STRUCT:
15161 
          self.ex = TransactionServiceException()
15162 
          self.ex.read(iprot)
15163 
        else:
15164 
          iprot.skip(ftype)
15165 
      else:
15166 
        iprot.skip(ftype)
15167 
      iprot.readFieldEnd()
15168 
    iprot.readStructEnd()
15169 
 
15170 
  def write(self, oprot):
15171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15173 
      return
15174 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15175 
    if self.ex is not None:
15176 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15177 
      self.ex.write(oprot)
15178 
      oprot.writeFieldEnd()
15179 
    oprot.writeFieldStop()
15180 
    oprot.writeStructEnd()
15181 
 
15182 
  def validate(self):
15183 
    return
15184 
 
15185 
 
15186 
  def __repr__(self):
15187 
    L = ['%s=%r' % (key, value)
15188 
      for key, value in self.__dict__.iteritems()]
15189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15190 
 
15191 
  def __eq__(self, other):
15192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15193 
 
15194 
  def __ne__(self, other):
15195 
    return not (self == other)
15196 
 
3064 chandransh 15197 
class getUndeliveredOrders_args:
1886 ankur.sing 15198 
  """
15199 
  Attributes:
3064 chandransh 15200 
   - providerId
15201 
   - warehouseId
1886 ankur.sing 15202 
  """
1627 ankur.sing 15203 
 
1886 ankur.sing 15204 
  thrift_spec = (
15205 
    None, # 0
3064 chandransh 15206 
    (1, TType.I64, 'providerId', None, None, ), # 1
15207 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15208 
  )
15209 
 
3064 chandransh 15210 
  def __init__(self, providerId=None, warehouseId=None,):
15211 
    self.providerId = providerId
15212 
    self.warehouseId = warehouseId
1886 ankur.sing 15213 
 
15214 
  def read(self, iprot):
15215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15217 
      return
15218 
    iprot.readStructBegin()
15219 
    while True:
15220 
      (fname, ftype, fid) = iprot.readFieldBegin()
15221 
      if ftype == TType.STOP:
15222 
        break
15223 
      if fid == 1:
15224 
        if ftype == TType.I64:
3064 chandransh 15225 
          self.providerId = iprot.readI64();
1886 ankur.sing 15226 
        else:
15227 
          iprot.skip(ftype)
3064 chandransh 15228 
      elif fid == 2:
15229 
        if ftype == TType.I64:
15230 
          self.warehouseId = iprot.readI64();
15231 
        else:
15232 
          iprot.skip(ftype)
1886 ankur.sing 15233 
      else:
15234 
        iprot.skip(ftype)
15235 
      iprot.readFieldEnd()
15236 
    iprot.readStructEnd()
15237 
 
15238 
  def write(self, oprot):
15239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15241 
      return
3064 chandransh 15242 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15243 
    if self.providerId is not None:
3064 chandransh 15244 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15245 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15246 
      oprot.writeFieldEnd()
3431 rajveer 15247 
    if self.warehouseId is not None:
3064 chandransh 15248 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15249 
      oprot.writeI64(self.warehouseId)
15250 
      oprot.writeFieldEnd()
1886 ankur.sing 15251 
    oprot.writeFieldStop()
15252 
    oprot.writeStructEnd()
15253 
 
3431 rajveer 15254 
  def validate(self):
15255 
    return
15256 
 
15257 
 
1886 ankur.sing 15258 
  def __repr__(self):
15259 
    L = ['%s=%r' % (key, value)
15260 
      for key, value in self.__dict__.iteritems()]
15261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15262 
 
15263 
  def __eq__(self, other):
15264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15265 
 
15266 
  def __ne__(self, other):
15267 
    return not (self == other)
15268 
 
3064 chandransh 15269 
class getUndeliveredOrders_result:
1886 ankur.sing 15270 
  """
15271 
  Attributes:
15272 
   - success
15273 
  """
15274 
 
15275 
  thrift_spec = (
15276 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15277 
  )
15278 
 
15279 
  def __init__(self, success=None,):
15280 
    self.success = success
15281 
 
15282 
  def read(self, iprot):
15283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15285 
      return
15286 
    iprot.readStructBegin()
15287 
    while True:
15288 
      (fname, ftype, fid) = iprot.readFieldBegin()
15289 
      if ftype == TType.STOP:
15290 
        break
15291 
      if fid == 0:
15292 
        if ftype == TType.LIST:
15293 
          self.success = []
6031 rajveer 15294 
          (_etype353, _size350) = iprot.readListBegin()
15295 
          for _i354 in xrange(_size350):
15296 
            _elem355 = Order()
15297 
            _elem355.read(iprot)
15298 
            self.success.append(_elem355)
1886 ankur.sing 15299 
          iprot.readListEnd()
15300 
        else:
15301 
          iprot.skip(ftype)
15302 
      else:
15303 
        iprot.skip(ftype)
15304 
      iprot.readFieldEnd()
15305 
    iprot.readStructEnd()
15306 
 
15307 
  def write(self, oprot):
15308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15310 
      return
3064 chandransh 15311 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15312 
    if self.success is not None:
1886 ankur.sing 15313 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15314 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15315 
      for iter356 in self.success:
15316 
        iter356.write(oprot)
1886 ankur.sing 15317 
      oprot.writeListEnd()
15318 
      oprot.writeFieldEnd()
15319 
    oprot.writeFieldStop()
15320 
    oprot.writeStructEnd()
15321 
 
3431 rajveer 15322 
  def validate(self):
15323 
    return
15324 
 
15325 
 
1886 ankur.sing 15326 
  def __repr__(self):
15327 
    L = ['%s=%r' % (key, value)
15328 
      for key, value in self.__dict__.iteritems()]
15329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15330 
 
15331 
  def __eq__(self, other):
15332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15333 
 
15334 
  def __ne__(self, other):
15335 
    return not (self == other)
15336 
 
4783 phani.kuma 15337 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15338 
 
15339 
  thrift_spec = (
15340 
  )
15341 
 
15342 
  def read(self, iprot):
15343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15345 
      return
15346 
    iprot.readStructBegin()
15347 
    while True:
15348 
      (fname, ftype, fid) = iprot.readFieldBegin()
15349 
      if ftype == TType.STOP:
15350 
        break
15351 
      else:
15352 
        iprot.skip(ftype)
15353 
      iprot.readFieldEnd()
15354 
    iprot.readStructEnd()
15355 
 
15356 
  def write(self, oprot):
15357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15359 
      return
15360 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15361 
    oprot.writeFieldStop()
15362 
    oprot.writeStructEnd()
15363 
 
15364 
  def validate(self):
15365 
    return
15366 
 
15367 
 
15368 
  def __repr__(self):
15369 
    L = ['%s=%r' % (key, value)
15370 
      for key, value in self.__dict__.iteritems()]
15371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15372 
 
15373 
  def __eq__(self, other):
15374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15375 
 
15376 
  def __ne__(self, other):
15377 
    return not (self == other)
15378 
 
15379 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15380 
  """
15381 
  Attributes:
15382 
   - success
15383 
  """
15384 
 
15385 
  thrift_spec = (
15386 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15387 
  )
15388 
 
15389 
  def __init__(self, success=None,):
15390 
    self.success = success
15391 
 
15392 
  def read(self, iprot):
15393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15395 
      return
15396 
    iprot.readStructBegin()
15397 
    while True:
15398 
      (fname, ftype, fid) = iprot.readFieldBegin()
15399 
      if ftype == TType.STOP:
15400 
        break
15401 
      if fid == 0:
15402 
        if ftype == TType.LIST:
15403 
          self.success = []
6031 rajveer 15404 
          (_etype360, _size357) = iprot.readListBegin()
15405 
          for _i361 in xrange(_size357):
15406 
            _elem362 = Order()
15407 
            _elem362.read(iprot)
15408 
            self.success.append(_elem362)
4783 phani.kuma 15409 
          iprot.readListEnd()
15410 
        else:
15411 
          iprot.skip(ftype)
15412 
      else:
15413 
        iprot.skip(ftype)
15414 
      iprot.readFieldEnd()
15415 
    iprot.readStructEnd()
15416 
 
15417 
  def write(self, oprot):
15418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15420 
      return
15421 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15422 
    if self.success is not None:
15423 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15424 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15425 
      for iter363 in self.success:
15426 
        iter363.write(oprot)
4783 phani.kuma 15427 
      oprot.writeListEnd()
15428 
      oprot.writeFieldEnd()
15429 
    oprot.writeFieldStop()
15430 
    oprot.writeStructEnd()
15431 
 
15432 
  def validate(self):
15433 
    return
15434 
 
15435 
 
15436 
  def __repr__(self):
15437 
    L = ['%s=%r' % (key, value)
15438 
      for key, value in self.__dict__.iteritems()]
15439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15440 
 
15441 
  def __eq__(self, other):
15442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15443 
 
15444 
  def __ne__(self, other):
15445 
    return not (self == other)
15446 
 
2536 chandransh 15447 
class toggleDOAFlag_args:
15448 
  """
15449 
  Attributes:
15450 
   - orderId
15451 
  """
1886 ankur.sing 15452 
 
2536 chandransh 15453 
  thrift_spec = (
15454 
    None, # 0
15455 
    (1, TType.I64, 'orderId', None, None, ), # 1
15456 
  )
15457 
 
15458 
  def __init__(self, orderId=None,):
15459 
    self.orderId = orderId
15460 
 
15461 
  def read(self, iprot):
15462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15464 
      return
15465 
    iprot.readStructBegin()
15466 
    while True:
15467 
      (fname, ftype, fid) = iprot.readFieldBegin()
15468 
      if ftype == TType.STOP:
15469 
        break
15470 
      if fid == 1:
15471 
        if ftype == TType.I64:
15472 
          self.orderId = iprot.readI64();
15473 
        else:
15474 
          iprot.skip(ftype)
15475 
      else:
15476 
        iprot.skip(ftype)
15477 
      iprot.readFieldEnd()
15478 
    iprot.readStructEnd()
15479 
 
15480 
  def write(self, oprot):
15481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15483 
      return
15484 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15485 
    if self.orderId is not None:
2536 chandransh 15486 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15487 
      oprot.writeI64(self.orderId)
15488 
      oprot.writeFieldEnd()
15489 
    oprot.writeFieldStop()
15490 
    oprot.writeStructEnd()
15491 
 
3431 rajveer 15492 
  def validate(self):
15493 
    return
15494 
 
15495 
 
2536 chandransh 15496 
  def __repr__(self):
15497 
    L = ['%s=%r' % (key, value)
15498 
      for key, value in self.__dict__.iteritems()]
15499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15500 
 
15501 
  def __eq__(self, other):
15502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15503 
 
15504 
  def __ne__(self, other):
15505 
    return not (self == other)
15506 
 
15507 
class toggleDOAFlag_result:
15508 
  """
15509 
  Attributes:
15510 
   - success
15511 
   - ex
15512 
  """
15513 
 
15514 
  thrift_spec = (
15515 
    (0, TType.BOOL, 'success', None, None, ), # 0
15516 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15517 
  )
15518 
 
15519 
  def __init__(self, success=None, ex=None,):
15520 
    self.success = success
15521 
    self.ex = ex
15522 
 
15523 
  def read(self, iprot):
15524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15526 
      return
15527 
    iprot.readStructBegin()
15528 
    while True:
15529 
      (fname, ftype, fid) = iprot.readFieldBegin()
15530 
      if ftype == TType.STOP:
15531 
        break
15532 
      if fid == 0:
15533 
        if ftype == TType.BOOL:
15534 
          self.success = iprot.readBool();
15535 
        else:
15536 
          iprot.skip(ftype)
15537 
      elif fid == 1:
15538 
        if ftype == TType.STRUCT:
15539 
          self.ex = TransactionServiceException()
15540 
          self.ex.read(iprot)
15541 
        else:
15542 
          iprot.skip(ftype)
15543 
      else:
15544 
        iprot.skip(ftype)
15545 
      iprot.readFieldEnd()
15546 
    iprot.readStructEnd()
15547 
 
15548 
  def write(self, oprot):
15549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15551 
      return
15552 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15553 
    if self.success is not None:
2536 chandransh 15554 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15555 
      oprot.writeBool(self.success)
15556 
      oprot.writeFieldEnd()
3431 rajveer 15557 
    if self.ex is not None:
2536 chandransh 15558 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15559 
      self.ex.write(oprot)
15560 
      oprot.writeFieldEnd()
15561 
    oprot.writeFieldStop()
15562 
    oprot.writeStructEnd()
15563 
 
3431 rajveer 15564 
  def validate(self):
15565 
    return
15566 
 
15567 
 
2536 chandransh 15568 
  def __repr__(self):
15569 
    L = ['%s=%r' % (key, value)
15570 
      for key, value in self.__dict__.iteritems()]
15571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15572 
 
15573 
  def __eq__(self, other):
15574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15575 
 
15576 
  def __ne__(self, other):
15577 
    return not (self == other)
15578 
 
4712 rajveer 15579 
class markOrderAsDelivered_args:
15580 
  """
15581 
  Attributes:
15582 
   - orderId
15583 
   - deliveryTimestamp
15584 
   - receiver
15585 
  """
15586 
 
15587 
  thrift_spec = None
15588 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15589 
    self.orderId = orderId
15590 
    self.deliveryTimestamp = deliveryTimestamp
15591 
    self.receiver = receiver
15592 
 
15593 
  def read(self, iprot):
15594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15596 
      return
15597 
    iprot.readStructBegin()
15598 
    while True:
15599 
      (fname, ftype, fid) = iprot.readFieldBegin()
15600 
      if ftype == TType.STOP:
15601 
        break
15602 
      if fid == 1:
15603 
        if ftype == TType.I64:
15604 
          self.orderId = iprot.readI64();
15605 
        else:
15606 
          iprot.skip(ftype)
15607 
      elif fid == 2:
15608 
        if ftype == TType.I64:
15609 
          self.deliveryTimestamp = iprot.readI64();
15610 
        else:
15611 
          iprot.skip(ftype)
15612 
      elif fid == -1:
15613 
        if ftype == TType.STRING:
15614 
          self.receiver = iprot.readString();
15615 
        else:
15616 
          iprot.skip(ftype)
15617 
      else:
15618 
        iprot.skip(ftype)
15619 
      iprot.readFieldEnd()
15620 
    iprot.readStructEnd()
15621 
 
15622 
  def write(self, oprot):
15623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15625 
      return
15626 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15627 
    if self.receiver is not None:
15628 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15629 
      oprot.writeString(self.receiver)
15630 
      oprot.writeFieldEnd()
15631 
    if self.orderId is not None:
15632 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15633 
      oprot.writeI64(self.orderId)
15634 
      oprot.writeFieldEnd()
15635 
    if self.deliveryTimestamp is not None:
15636 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15637 
      oprot.writeI64(self.deliveryTimestamp)
15638 
      oprot.writeFieldEnd()
15639 
    oprot.writeFieldStop()
15640 
    oprot.writeStructEnd()
15641 
 
15642 
  def validate(self):
15643 
    return
15644 
 
15645 
 
15646 
  def __repr__(self):
15647 
    L = ['%s=%r' % (key, value)
15648 
      for key, value in self.__dict__.iteritems()]
15649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15650 
 
15651 
  def __eq__(self, other):
15652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15653 
 
15654 
  def __ne__(self, other):
15655 
    return not (self == other)
15656 
 
15657 
class markOrderAsDelivered_result:
15658 
  """
15659 
  Attributes:
15660 
   - ex
15661 
  """
15662 
 
15663 
  thrift_spec = (
15664 
    None, # 0
15665 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15666 
  )
15667 
 
15668 
  def __init__(self, ex=None,):
15669 
    self.ex = ex
15670 
 
15671 
  def read(self, iprot):
15672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15674 
      return
15675 
    iprot.readStructBegin()
15676 
    while True:
15677 
      (fname, ftype, fid) = iprot.readFieldBegin()
15678 
      if ftype == TType.STOP:
15679 
        break
15680 
      if fid == 1:
15681 
        if ftype == TType.STRUCT:
15682 
          self.ex = TransactionServiceException()
15683 
          self.ex.read(iprot)
15684 
        else:
15685 
          iprot.skip(ftype)
15686 
      else:
15687 
        iprot.skip(ftype)
15688 
      iprot.readFieldEnd()
15689 
    iprot.readStructEnd()
15690 
 
15691 
  def write(self, oprot):
15692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15694 
      return
15695 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15696 
    if self.ex is not None:
15697 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15698 
      self.ex.write(oprot)
15699 
      oprot.writeFieldEnd()
15700 
    oprot.writeFieldStop()
15701 
    oprot.writeStructEnd()
15702 
 
15703 
  def validate(self):
15704 
    return
15705 
 
15706 
 
15707 
  def __repr__(self):
15708 
    L = ['%s=%r' % (key, value)
15709 
      for key, value in self.__dict__.iteritems()]
15710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15711 
 
15712 
  def __eq__(self, other):
15713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15714 
 
15715 
  def __ne__(self, other):
15716 
    return not (self == other)
15717 
 
5553 rajveer 15718 
class markOrderAsReceivedAtStore_args:
15719 
  """
15720 
  Attributes:
15721 
   - orderId
15722 
   - deliveryTimestamp
15723 
  """
15724 
 
15725 
  thrift_spec = (
15726 
    None, # 0
15727 
    (1, TType.I64, 'orderId', None, None, ), # 1
15728 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15729 
  )
15730 
 
15731 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15732 
    self.orderId = orderId
15733 
    self.deliveryTimestamp = deliveryTimestamp
15734 
 
15735 
  def read(self, iprot):
15736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15738 
      return
15739 
    iprot.readStructBegin()
15740 
    while True:
15741 
      (fname, ftype, fid) = iprot.readFieldBegin()
15742 
      if ftype == TType.STOP:
15743 
        break
15744 
      if fid == 1:
15745 
        if ftype == TType.I64:
15746 
          self.orderId = iprot.readI64();
15747 
        else:
15748 
          iprot.skip(ftype)
15749 
      elif fid == 2:
15750 
        if ftype == TType.I64:
15751 
          self.deliveryTimestamp = iprot.readI64();
15752 
        else:
15753 
          iprot.skip(ftype)
15754 
      else:
15755 
        iprot.skip(ftype)
15756 
      iprot.readFieldEnd()
15757 
    iprot.readStructEnd()
15758 
 
15759 
  def write(self, oprot):
15760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15762 
      return
15763 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15764 
    if self.orderId is not None:
15765 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15766 
      oprot.writeI64(self.orderId)
15767 
      oprot.writeFieldEnd()
15768 
    if self.deliveryTimestamp is not None:
15769 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15770 
      oprot.writeI64(self.deliveryTimestamp)
15771 
      oprot.writeFieldEnd()
15772 
    oprot.writeFieldStop()
15773 
    oprot.writeStructEnd()
15774 
 
15775 
  def validate(self):
15776 
    return
15777 
 
15778 
 
15779 
  def __repr__(self):
15780 
    L = ['%s=%r' % (key, value)
15781 
      for key, value in self.__dict__.iteritems()]
15782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15783 
 
15784 
  def __eq__(self, other):
15785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15786 
 
15787 
  def __ne__(self, other):
15788 
    return not (self == other)
15789 
 
15790 
class markOrderAsReceivedAtStore_result:
15791 
  """
15792 
  Attributes:
15793 
   - ex
15794 
  """
15795 
 
15796 
  thrift_spec = (
15797 
    None, # 0
15798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15799 
  )
15800 
 
15801 
  def __init__(self, ex=None,):
15802 
    self.ex = ex
15803 
 
15804 
  def read(self, iprot):
15805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15807 
      return
15808 
    iprot.readStructBegin()
15809 
    while True:
15810 
      (fname, ftype, fid) = iprot.readFieldBegin()
15811 
      if ftype == TType.STOP:
15812 
        break
15813 
      if fid == 1:
15814 
        if ftype == TType.STRUCT:
15815 
          self.ex = TransactionServiceException()
15816 
          self.ex.read(iprot)
15817 
        else:
15818 
          iprot.skip(ftype)
15819 
      else:
15820 
        iprot.skip(ftype)
15821 
      iprot.readFieldEnd()
15822 
    iprot.readStructEnd()
15823 
 
15824 
  def write(self, oprot):
15825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15827 
      return
15828 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15829 
    if self.ex is not None:
15830 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15831 
      self.ex.write(oprot)
15832 
      oprot.writeFieldEnd()
15833 
    oprot.writeFieldStop()
15834 
    oprot.writeStructEnd()
15835 
 
15836 
  def validate(self):
15837 
    return
15838 
 
15839 
 
15840 
  def __repr__(self):
15841 
    L = ['%s=%r' % (key, value)
15842 
      for key, value in self.__dict__.iteritems()]
15843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15844 
 
15845 
  def __eq__(self, other):
15846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15847 
 
15848 
  def __ne__(self, other):
15849 
    return not (self == other)
15850 
 
4454 rajveer 15851 
class markOrderDoaRequestReceived_args:
15852 
  """
15853 
  Attributes:
15854 
   - orderId
15855 
  """
15856 
 
15857 
  thrift_spec = (
15858 
    None, # 0
15859 
    (1, TType.I64, 'orderId', None, None, ), # 1
15860 
  )
15861 
 
15862 
  def __init__(self, orderId=None,):
15863 
    self.orderId = orderId
15864 
 
15865 
  def read(self, iprot):
15866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15868 
      return
15869 
    iprot.readStructBegin()
15870 
    while True:
15871 
      (fname, ftype, fid) = iprot.readFieldBegin()
15872 
      if ftype == TType.STOP:
15873 
        break
15874 
      if fid == 1:
15875 
        if ftype == TType.I64:
15876 
          self.orderId = iprot.readI64();
15877 
        else:
15878 
          iprot.skip(ftype)
15879 
      else:
15880 
        iprot.skip(ftype)
15881 
      iprot.readFieldEnd()
15882 
    iprot.readStructEnd()
15883 
 
15884 
  def write(self, oprot):
15885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15887 
      return
15888 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
15889 
    if self.orderId is not None:
15890 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15891 
      oprot.writeI64(self.orderId)
15892 
      oprot.writeFieldEnd()
15893 
    oprot.writeFieldStop()
15894 
    oprot.writeStructEnd()
15895 
 
15896 
  def validate(self):
15897 
    return
15898 
 
15899 
 
15900 
  def __repr__(self):
15901 
    L = ['%s=%r' % (key, value)
15902 
      for key, value in self.__dict__.iteritems()]
15903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15904 
 
15905 
  def __eq__(self, other):
15906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15907 
 
15908 
  def __ne__(self, other):
15909 
    return not (self == other)
15910 
 
15911 
class markOrderDoaRequestReceived_result:
15912 
  """
15913 
  Attributes:
15914 
   - success
15915 
   - ex
15916 
  """
15917 
 
15918 
  thrift_spec = (
15919 
    (0, TType.BOOL, 'success', None, None, ), # 0
15920 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15921 
  )
15922 
 
15923 
  def __init__(self, success=None, ex=None,):
15924 
    self.success = success
15925 
    self.ex = ex
15926 
 
15927 
  def read(self, iprot):
15928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15930 
      return
15931 
    iprot.readStructBegin()
15932 
    while True:
15933 
      (fname, ftype, fid) = iprot.readFieldBegin()
15934 
      if ftype == TType.STOP:
15935 
        break
15936 
      if fid == 0:
15937 
        if ftype == TType.BOOL:
15938 
          self.success = iprot.readBool();
15939 
        else:
15940 
          iprot.skip(ftype)
15941 
      elif fid == 1:
15942 
        if ftype == TType.STRUCT:
15943 
          self.ex = TransactionServiceException()
15944 
          self.ex.read(iprot)
15945 
        else:
15946 
          iprot.skip(ftype)
15947 
      else:
15948 
        iprot.skip(ftype)
15949 
      iprot.readFieldEnd()
15950 
    iprot.readStructEnd()
15951 
 
15952 
  def write(self, oprot):
15953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15955 
      return
15956 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
15957 
    if self.success is not None:
15958 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15959 
      oprot.writeBool(self.success)
15960 
      oprot.writeFieldEnd()
15961 
    if self.ex is not None:
15962 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15963 
      self.ex.write(oprot)
15964 
      oprot.writeFieldEnd()
15965 
    oprot.writeFieldStop()
15966 
    oprot.writeStructEnd()
15967 
 
15968 
  def validate(self):
15969 
    return
15970 
 
15971 
 
15972 
  def __repr__(self):
15973 
    L = ['%s=%r' % (key, value)
15974 
      for key, value in self.__dict__.iteritems()]
15975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15976 
 
15977 
  def __eq__(self, other):
15978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15979 
 
15980 
  def __ne__(self, other):
15981 
    return not (self == other)
15982 
 
15983 
class markOrderDoaRequestAuthorized_args:
15984 
  """
15985 
  Attributes:
15986 
   - orderId
15987 
   - isAuthorized
15988 
  """
15989 
 
15990 
  thrift_spec = (
15991 
    None, # 0
15992 
    (1, TType.I64, 'orderId', None, None, ), # 1
15993 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15994 
  )
15995 
 
15996 
  def __init__(self, orderId=None, isAuthorized=None,):
15997 
    self.orderId = orderId
15998 
    self.isAuthorized = isAuthorized
15999 
 
16000 
  def read(self, iprot):
16001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16003 
      return
16004 
    iprot.readStructBegin()
16005 
    while True:
16006 
      (fname, ftype, fid) = iprot.readFieldBegin()
16007 
      if ftype == TType.STOP:
16008 
        break
16009 
      if fid == 1:
16010 
        if ftype == TType.I64:
16011 
          self.orderId = iprot.readI64();
16012 
        else:
16013 
          iprot.skip(ftype)
16014 
      elif fid == 2:
16015 
        if ftype == TType.BOOL:
16016 
          self.isAuthorized = iprot.readBool();
16017 
        else:
16018 
          iprot.skip(ftype)
16019 
      else:
16020 
        iprot.skip(ftype)
16021 
      iprot.readFieldEnd()
16022 
    iprot.readStructEnd()
16023 
 
16024 
  def write(self, oprot):
16025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16027 
      return
16028 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16029 
    if self.orderId is not None:
16030 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16031 
      oprot.writeI64(self.orderId)
16032 
      oprot.writeFieldEnd()
16033 
    if self.isAuthorized is not None:
16034 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16035 
      oprot.writeBool(self.isAuthorized)
16036 
      oprot.writeFieldEnd()
16037 
    oprot.writeFieldStop()
16038 
    oprot.writeStructEnd()
16039 
 
16040 
  def validate(self):
16041 
    return
16042 
 
16043 
 
16044 
  def __repr__(self):
16045 
    L = ['%s=%r' % (key, value)
16046 
      for key, value in self.__dict__.iteritems()]
16047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16048 
 
16049 
  def __eq__(self, other):
16050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16051 
 
16052 
  def __ne__(self, other):
16053 
    return not (self == other)
16054 
 
16055 
class markOrderDoaRequestAuthorized_result:
16056 
  """
16057 
  Attributes:
16058 
   - success
16059 
   - ex
16060 
  """
16061 
 
16062 
  thrift_spec = (
16063 
    (0, TType.BOOL, 'success', None, None, ), # 0
16064 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16065 
  )
16066 
 
16067 
  def __init__(self, success=None, ex=None,):
16068 
    self.success = success
16069 
    self.ex = ex
16070 
 
16071 
  def read(self, iprot):
16072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16074 
      return
16075 
    iprot.readStructBegin()
16076 
    while True:
16077 
      (fname, ftype, fid) = iprot.readFieldBegin()
16078 
      if ftype == TType.STOP:
16079 
        break
16080 
      if fid == 0:
16081 
        if ftype == TType.BOOL:
16082 
          self.success = iprot.readBool();
16083 
        else:
16084 
          iprot.skip(ftype)
16085 
      elif fid == 1:
16086 
        if ftype == TType.STRUCT:
16087 
          self.ex = TransactionServiceException()
16088 
          self.ex.read(iprot)
16089 
        else:
16090 
          iprot.skip(ftype)
16091 
      else:
16092 
        iprot.skip(ftype)
16093 
      iprot.readFieldEnd()
16094 
    iprot.readStructEnd()
16095 
 
16096 
  def write(self, oprot):
16097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16099 
      return
16100 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16101 
    if self.success is not None:
16102 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16103 
      oprot.writeBool(self.success)
16104 
      oprot.writeFieldEnd()
16105 
    if self.ex is not None:
16106 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16107 
      self.ex.write(oprot)
16108 
      oprot.writeFieldEnd()
16109 
    oprot.writeFieldStop()
16110 
    oprot.writeStructEnd()
16111 
 
16112 
  def validate(self):
16113 
    return
16114 
 
16115 
 
16116 
  def __repr__(self):
16117 
    L = ['%s=%r' % (key, value)
16118 
      for key, value in self.__dict__.iteritems()]
16119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16120 
 
16121 
  def __eq__(self, other):
16122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16123 
 
16124 
  def __ne__(self, other):
16125 
    return not (self == other)
16126 
 
4488 rajveer 16127 
class markOrderReturnRequestReceived_args:
16128 
  """
16129 
  Attributes:
16130 
   - orderId
16131 
  """
16132 
 
16133 
  thrift_spec = (
16134 
    None, # 0
16135 
    (1, TType.I64, 'orderId', None, None, ), # 1
16136 
  )
16137 
 
16138 
  def __init__(self, orderId=None,):
16139 
    self.orderId = orderId
16140 
 
16141 
  def read(self, iprot):
16142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16144 
      return
16145 
    iprot.readStructBegin()
16146 
    while True:
16147 
      (fname, ftype, fid) = iprot.readFieldBegin()
16148 
      if ftype == TType.STOP:
16149 
        break
16150 
      if fid == 1:
16151 
        if ftype == TType.I64:
16152 
          self.orderId = iprot.readI64();
16153 
        else:
16154 
          iprot.skip(ftype)
16155 
      else:
16156 
        iprot.skip(ftype)
16157 
      iprot.readFieldEnd()
16158 
    iprot.readStructEnd()
16159 
 
16160 
  def write(self, oprot):
16161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16163 
      return
16164 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16165 
    if self.orderId is not None:
16166 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16167 
      oprot.writeI64(self.orderId)
16168 
      oprot.writeFieldEnd()
16169 
    oprot.writeFieldStop()
16170 
    oprot.writeStructEnd()
16171 
 
16172 
  def validate(self):
16173 
    return
16174 
 
16175 
 
16176 
  def __repr__(self):
16177 
    L = ['%s=%r' % (key, value)
16178 
      for key, value in self.__dict__.iteritems()]
16179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16180 
 
16181 
  def __eq__(self, other):
16182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16183 
 
16184 
  def __ne__(self, other):
16185 
    return not (self == other)
16186 
 
16187 
class markOrderReturnRequestReceived_result:
16188 
  """
16189 
  Attributes:
16190 
   - success
16191 
   - ex
16192 
  """
16193 
 
16194 
  thrift_spec = (
16195 
    (0, TType.BOOL, 'success', None, None, ), # 0
16196 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16197 
  )
16198 
 
16199 
  def __init__(self, success=None, ex=None,):
16200 
    self.success = success
16201 
    self.ex = ex
16202 
 
16203 
  def read(self, iprot):
16204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16206 
      return
16207 
    iprot.readStructBegin()
16208 
    while True:
16209 
      (fname, ftype, fid) = iprot.readFieldBegin()
16210 
      if ftype == TType.STOP:
16211 
        break
16212 
      if fid == 0:
16213 
        if ftype == TType.BOOL:
16214 
          self.success = iprot.readBool();
16215 
        else:
16216 
          iprot.skip(ftype)
16217 
      elif fid == 1:
16218 
        if ftype == TType.STRUCT:
16219 
          self.ex = TransactionServiceException()
16220 
          self.ex.read(iprot)
16221 
        else:
16222 
          iprot.skip(ftype)
16223 
      else:
16224 
        iprot.skip(ftype)
16225 
      iprot.readFieldEnd()
16226 
    iprot.readStructEnd()
16227 
 
16228 
  def write(self, oprot):
16229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16231 
      return
16232 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16233 
    if self.success is not None:
16234 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16235 
      oprot.writeBool(self.success)
16236 
      oprot.writeFieldEnd()
16237 
    if self.ex is not None:
16238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16239 
      self.ex.write(oprot)
16240 
      oprot.writeFieldEnd()
16241 
    oprot.writeFieldStop()
16242 
    oprot.writeStructEnd()
16243 
 
16244 
  def validate(self):
16245 
    return
16246 
 
16247 
 
16248 
  def __repr__(self):
16249 
    L = ['%s=%r' % (key, value)
16250 
      for key, value in self.__dict__.iteritems()]
16251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16252 
 
16253 
  def __eq__(self, other):
16254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16255 
 
16256 
  def __ne__(self, other):
16257 
    return not (self == other)
16258 
 
16259 
class markOrderReturnRequestAuthorized_args:
16260 
  """
16261 
  Attributes:
16262 
   - orderId
16263 
   - isAuthorized
16264 
  """
16265 
 
16266 
  thrift_spec = (
16267 
    None, # 0
16268 
    (1, TType.I64, 'orderId', None, None, ), # 1
16269 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16270 
  )
16271 
 
16272 
  def __init__(self, orderId=None, isAuthorized=None,):
16273 
    self.orderId = orderId
16274 
    self.isAuthorized = isAuthorized
16275 
 
16276 
  def read(self, iprot):
16277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16279 
      return
16280 
    iprot.readStructBegin()
16281 
    while True:
16282 
      (fname, ftype, fid) = iprot.readFieldBegin()
16283 
      if ftype == TType.STOP:
16284 
        break
16285 
      if fid == 1:
16286 
        if ftype == TType.I64:
16287 
          self.orderId = iprot.readI64();
16288 
        else:
16289 
          iprot.skip(ftype)
16290 
      elif fid == 2:
16291 
        if ftype == TType.BOOL:
16292 
          self.isAuthorized = iprot.readBool();
16293 
        else:
16294 
          iprot.skip(ftype)
16295 
      else:
16296 
        iprot.skip(ftype)
16297 
      iprot.readFieldEnd()
16298 
    iprot.readStructEnd()
16299 
 
16300 
  def write(self, oprot):
16301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16303 
      return
16304 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16305 
    if self.orderId is not None:
16306 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16307 
      oprot.writeI64(self.orderId)
16308 
      oprot.writeFieldEnd()
16309 
    if self.isAuthorized is not None:
16310 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16311 
      oprot.writeBool(self.isAuthorized)
16312 
      oprot.writeFieldEnd()
16313 
    oprot.writeFieldStop()
16314 
    oprot.writeStructEnd()
16315 
 
16316 
  def validate(self):
16317 
    return
16318 
 
16319 
 
16320 
  def __repr__(self):
16321 
    L = ['%s=%r' % (key, value)
16322 
      for key, value in self.__dict__.iteritems()]
16323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16324 
 
16325 
  def __eq__(self, other):
16326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16327 
 
16328 
  def __ne__(self, other):
16329 
    return not (self == other)
16330 
 
16331 
class markOrderReturnRequestAuthorized_result:
16332 
  """
16333 
  Attributes:
16334 
   - success
16335 
   - ex
16336 
  """
16337 
 
16338 
  thrift_spec = (
16339 
    (0, TType.BOOL, 'success', None, None, ), # 0
16340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16341 
  )
16342 
 
16343 
  def __init__(self, success=None, ex=None,):
16344 
    self.success = success
16345 
    self.ex = ex
16346 
 
16347 
  def read(self, iprot):
16348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16350 
      return
16351 
    iprot.readStructBegin()
16352 
    while True:
16353 
      (fname, ftype, fid) = iprot.readFieldBegin()
16354 
      if ftype == TType.STOP:
16355 
        break
16356 
      if fid == 0:
16357 
        if ftype == TType.BOOL:
16358 
          self.success = iprot.readBool();
16359 
        else:
16360 
          iprot.skip(ftype)
16361 
      elif fid == 1:
16362 
        if ftype == TType.STRUCT:
16363 
          self.ex = TransactionServiceException()
16364 
          self.ex.read(iprot)
16365 
        else:
16366 
          iprot.skip(ftype)
16367 
      else:
16368 
        iprot.skip(ftype)
16369 
      iprot.readFieldEnd()
16370 
    iprot.readStructEnd()
16371 
 
16372 
  def write(self, oprot):
16373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16375 
      return
16376 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16377 
    if self.success is not None:
16378 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16379 
      oprot.writeBool(self.success)
16380 
      oprot.writeFieldEnd()
16381 
    if self.ex is not None:
16382 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16383 
      self.ex.write(oprot)
16384 
      oprot.writeFieldEnd()
16385 
    oprot.writeFieldStop()
16386 
    oprot.writeStructEnd()
16387 
 
16388 
  def validate(self):
16389 
    return
16390 
 
16391 
 
16392 
  def __repr__(self):
16393 
    L = ['%s=%r' % (key, value)
16394 
      for key, value in self.__dict__.iteritems()]
16395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16396 
 
16397 
  def __eq__(self, other):
16398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16399 
 
16400 
  def __ne__(self, other):
16401 
    return not (self == other)
16402 
 
2536 chandransh 16403 
class requestPickupNumber_args:
16404 
  """
16405 
  Attributes:
16406 
   - orderId
4579 rajveer 16407 
   - providerId
2536 chandransh 16408 
  """
16409 
 
16410 
  thrift_spec = (
16411 
    None, # 0
16412 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16413 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16414 
  )
16415 
 
4579 rajveer 16416 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16417 
    self.orderId = orderId
4579 rajveer 16418 
    self.providerId = providerId
2536 chandransh 16419 
 
16420 
  def read(self, iprot):
16421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16423 
      return
16424 
    iprot.readStructBegin()
16425 
    while True:
16426 
      (fname, ftype, fid) = iprot.readFieldBegin()
16427 
      if ftype == TType.STOP:
16428 
        break
16429 
      if fid == 1:
16430 
        if ftype == TType.I64:
16431 
          self.orderId = iprot.readI64();
16432 
        else:
16433 
          iprot.skip(ftype)
4579 rajveer 16434 
      elif fid == 2:
16435 
        if ftype == TType.I64:
16436 
          self.providerId = iprot.readI64();
16437 
        else:
16438 
          iprot.skip(ftype)
2536 chandransh 16439 
      else:
16440 
        iprot.skip(ftype)
16441 
      iprot.readFieldEnd()
16442 
    iprot.readStructEnd()
16443 
 
16444 
  def write(self, oprot):
16445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16447 
      return
16448 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16449 
    if self.orderId is not None:
2536 chandransh 16450 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16451 
      oprot.writeI64(self.orderId)
16452 
      oprot.writeFieldEnd()
4579 rajveer 16453 
    if self.providerId is not None:
16454 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16455 
      oprot.writeI64(self.providerId)
16456 
      oprot.writeFieldEnd()
2536 chandransh 16457 
    oprot.writeFieldStop()
16458 
    oprot.writeStructEnd()
16459 
 
3431 rajveer 16460 
  def validate(self):
16461 
    return
16462 
 
16463 
 
2536 chandransh 16464 
  def __repr__(self):
16465 
    L = ['%s=%r' % (key, value)
16466 
      for key, value in self.__dict__.iteritems()]
16467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16468 
 
16469 
  def __eq__(self, other):
16470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16471 
 
16472 
  def __ne__(self, other):
16473 
    return not (self == other)
16474 
 
16475 
class requestPickupNumber_result:
16476 
  """
16477 
  Attributes:
16478 
   - success
16479 
   - ex
16480 
  """
16481 
 
16482 
  thrift_spec = (
16483 
    (0, TType.BOOL, 'success', None, None, ), # 0
16484 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16485 
  )
16486 
 
16487 
  def __init__(self, success=None, ex=None,):
16488 
    self.success = success
16489 
    self.ex = ex
16490 
 
16491 
  def read(self, iprot):
16492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16494 
      return
16495 
    iprot.readStructBegin()
16496 
    while True:
16497 
      (fname, ftype, fid) = iprot.readFieldBegin()
16498 
      if ftype == TType.STOP:
16499 
        break
16500 
      if fid == 0:
16501 
        if ftype == TType.BOOL:
16502 
          self.success = iprot.readBool();
16503 
        else:
16504 
          iprot.skip(ftype)
16505 
      elif fid == 1:
16506 
        if ftype == TType.STRUCT:
16507 
          self.ex = TransactionServiceException()
16508 
          self.ex.read(iprot)
16509 
        else:
16510 
          iprot.skip(ftype)
16511 
      else:
16512 
        iprot.skip(ftype)
16513 
      iprot.readFieldEnd()
16514 
    iprot.readStructEnd()
16515 
 
16516 
  def write(self, oprot):
16517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16519 
      return
16520 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16521 
    if self.success is not None:
2536 chandransh 16522 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16523 
      oprot.writeBool(self.success)
16524 
      oprot.writeFieldEnd()
3431 rajveer 16525 
    if self.ex is not None:
2536 chandransh 16526 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16527 
      self.ex.write(oprot)
16528 
      oprot.writeFieldEnd()
16529 
    oprot.writeFieldStop()
16530 
    oprot.writeStructEnd()
16531 
 
3431 rajveer 16532 
  def validate(self):
16533 
    return
16534 
 
16535 
 
2536 chandransh 16536 
  def __repr__(self):
16537 
    L = ['%s=%r' % (key, value)
16538 
      for key, value in self.__dict__.iteritems()]
16539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16540 
 
16541 
  def __eq__(self, other):
16542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16543 
 
16544 
  def __ne__(self, other):
16545 
    return not (self == other)
16546 
 
16547 
class authorizePickup_args:
16548 
  """
16549 
  Attributes:
16550 
   - orderId
16551 
   - pickupNumber
4602 rajveer 16552 
   - providerId
2536 chandransh 16553 
  """
16554 
 
16555 
  thrift_spec = (
16556 
    None, # 0
16557 
    (1, TType.I64, 'orderId', None, None, ), # 1
16558 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16559 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16560 
  )
16561 
 
4602 rajveer 16562 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16563 
    self.orderId = orderId
16564 
    self.pickupNumber = pickupNumber
4602 rajveer 16565 
    self.providerId = providerId
2536 chandransh 16566 
 
16567 
  def read(self, iprot):
16568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16570 
      return
16571 
    iprot.readStructBegin()
16572 
    while True:
16573 
      (fname, ftype, fid) = iprot.readFieldBegin()
16574 
      if ftype == TType.STOP:
16575 
        break
16576 
      if fid == 1:
16577 
        if ftype == TType.I64:
16578 
          self.orderId = iprot.readI64();
16579 
        else:
16580 
          iprot.skip(ftype)
16581 
      elif fid == 2:
16582 
        if ftype == TType.STRING:
16583 
          self.pickupNumber = iprot.readString();
16584 
        else:
16585 
          iprot.skip(ftype)
4602 rajveer 16586 
      elif fid == 3:
16587 
        if ftype == TType.I64:
16588 
          self.providerId = iprot.readI64();
16589 
        else:
16590 
          iprot.skip(ftype)
2536 chandransh 16591 
      else:
16592 
        iprot.skip(ftype)
16593 
      iprot.readFieldEnd()
16594 
    iprot.readStructEnd()
16595 
 
16596 
  def write(self, oprot):
16597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16599 
      return
16600 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16601 
    if self.orderId is not None:
2536 chandransh 16602 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16603 
      oprot.writeI64(self.orderId)
16604 
      oprot.writeFieldEnd()
3431 rajveer 16605 
    if self.pickupNumber is not None:
2536 chandransh 16606 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16607 
      oprot.writeString(self.pickupNumber)
16608 
      oprot.writeFieldEnd()
4602 rajveer 16609 
    if self.providerId is not None:
16610 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16611 
      oprot.writeI64(self.providerId)
16612 
      oprot.writeFieldEnd()
2536 chandransh 16613 
    oprot.writeFieldStop()
16614 
    oprot.writeStructEnd()
16615 
 
3431 rajveer 16616 
  def validate(self):
16617 
    return
16618 
 
16619 
 
2536 chandransh 16620 
  def __repr__(self):
16621 
    L = ['%s=%r' % (key, value)
16622 
      for key, value in self.__dict__.iteritems()]
16623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16624 
 
16625 
  def __eq__(self, other):
16626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16627 
 
16628 
  def __ne__(self, other):
16629 
    return not (self == other)
16630 
 
16631 
class authorizePickup_result:
16632 
  """
16633 
  Attributes:
16634 
   - success
16635 
   - ex
16636 
  """
16637 
 
16638 
  thrift_spec = (
16639 
    (0, TType.BOOL, 'success', None, None, ), # 0
16640 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16641 
  )
16642 
 
16643 
  def __init__(self, success=None, ex=None,):
16644 
    self.success = success
16645 
    self.ex = ex
16646 
 
16647 
  def read(self, iprot):
16648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16650 
      return
16651 
    iprot.readStructBegin()
16652 
    while True:
16653 
      (fname, ftype, fid) = iprot.readFieldBegin()
16654 
      if ftype == TType.STOP:
16655 
        break
16656 
      if fid == 0:
16657 
        if ftype == TType.BOOL:
16658 
          self.success = iprot.readBool();
16659 
        else:
16660 
          iprot.skip(ftype)
16661 
      elif fid == 1:
16662 
        if ftype == TType.STRUCT:
16663 
          self.ex = TransactionServiceException()
16664 
          self.ex.read(iprot)
16665 
        else:
16666 
          iprot.skip(ftype)
16667 
      else:
16668 
        iprot.skip(ftype)
16669 
      iprot.readFieldEnd()
16670 
    iprot.readStructEnd()
16671 
 
16672 
  def write(self, oprot):
16673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16675 
      return
16676 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16677 
    if self.success is not None:
2536 chandransh 16678 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16679 
      oprot.writeBool(self.success)
16680 
      oprot.writeFieldEnd()
3431 rajveer 16681 
    if self.ex is not None:
2536 chandransh 16682 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16683 
      self.ex.write(oprot)
16684 
      oprot.writeFieldEnd()
16685 
    oprot.writeFieldStop()
16686 
    oprot.writeStructEnd()
16687 
 
3431 rajveer 16688 
  def validate(self):
16689 
    return
16690 
 
16691 
 
2536 chandransh 16692 
  def __repr__(self):
16693 
    L = ['%s=%r' % (key, value)
16694 
      for key, value in self.__dict__.iteritems()]
16695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16696 
 
16697 
  def __eq__(self, other):
16698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16699 
 
16700 
  def __ne__(self, other):
16701 
    return not (self == other)
16702 
 
2764 chandransh 16703 
class markDoasAsPickedUp_args:
16704 
  """
16705 
  Attributes:
16706 
   - providerId
16707 
   - pickupDetails
16708 
  """
16709 
 
16710 
  thrift_spec = (
16711 
    None, # 0
16712 
    (1, TType.I64, 'providerId', None, None, ), # 1
16713 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16714 
  )
16715 
 
16716 
  def __init__(self, providerId=None, pickupDetails=None,):
16717 
    self.providerId = providerId
16718 
    self.pickupDetails = pickupDetails
16719 
 
16720 
  def read(self, iprot):
16721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16723 
      return
16724 
    iprot.readStructBegin()
16725 
    while True:
16726 
      (fname, ftype, fid) = iprot.readFieldBegin()
16727 
      if ftype == TType.STOP:
16728 
        break
16729 
      if fid == 1:
16730 
        if ftype == TType.I64:
16731 
          self.providerId = iprot.readI64();
16732 
        else:
16733 
          iprot.skip(ftype)
16734 
      elif fid == 2:
16735 
        if ftype == TType.MAP:
16736 
          self.pickupDetails = {}
6031 rajveer 16737 
          (_ktype365, _vtype366, _size364 ) = iprot.readMapBegin()
16738 
          for _i368 in xrange(_size364):
16739 
            _key369 = iprot.readString();
16740 
            _val370 = iprot.readString();
16741 
            self.pickupDetails[_key369] = _val370
2764 chandransh 16742 
          iprot.readMapEnd()
16743 
        else:
16744 
          iprot.skip(ftype)
16745 
      else:
16746 
        iprot.skip(ftype)
16747 
      iprot.readFieldEnd()
16748 
    iprot.readStructEnd()
16749 
 
16750 
  def write(self, oprot):
16751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16753 
      return
16754 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16755 
    if self.providerId is not None:
2764 chandransh 16756 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16757 
      oprot.writeI64(self.providerId)
16758 
      oprot.writeFieldEnd()
3431 rajveer 16759 
    if self.pickupDetails is not None:
2764 chandransh 16760 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16761 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 16762 
      for kiter371,viter372 in self.pickupDetails.items():
16763 
        oprot.writeString(kiter371)
16764 
        oprot.writeString(viter372)
2764 chandransh 16765 
      oprot.writeMapEnd()
16766 
      oprot.writeFieldEnd()
16767 
    oprot.writeFieldStop()
16768 
    oprot.writeStructEnd()
16769 
 
3431 rajveer 16770 
  def validate(self):
16771 
    return
16772 
 
16773 
 
2764 chandransh 16774 
  def __repr__(self):
16775 
    L = ['%s=%r' % (key, value)
16776 
      for key, value in self.__dict__.iteritems()]
16777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16778 
 
16779 
  def __eq__(self, other):
16780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16781 
 
16782 
  def __ne__(self, other):
16783 
    return not (self == other)
16784 
 
16785 
class markDoasAsPickedUp_result:
4910 phani.kuma 16786 
 
16787 
  thrift_spec = (
16788 
  )
16789 
 
16790 
  def read(self, iprot):
16791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16793 
      return
16794 
    iprot.readStructBegin()
16795 
    while True:
16796 
      (fname, ftype, fid) = iprot.readFieldBegin()
16797 
      if ftype == TType.STOP:
16798 
        break
16799 
      else:
16800 
        iprot.skip(ftype)
16801 
      iprot.readFieldEnd()
16802 
    iprot.readStructEnd()
16803 
 
16804 
  def write(self, oprot):
16805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16807 
      return
16808 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
16809 
    oprot.writeFieldStop()
16810 
    oprot.writeStructEnd()
16811 
 
16812 
  def validate(self):
16813 
    return
16814 
 
16815 
 
16816 
  def __repr__(self):
16817 
    L = ['%s=%r' % (key, value)
16818 
      for key, value in self.__dict__.iteritems()]
16819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16820 
 
16821 
  def __eq__(self, other):
16822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16823 
 
16824 
  def __ne__(self, other):
16825 
    return not (self == other)
16826 
 
16827 
class getDoasNotPickedUp_args:
2764 chandransh 16828 
  """
16829 
  Attributes:
4910 phani.kuma 16830 
   - providerId
16831 
  """
16832 
 
16833 
  thrift_spec = (
16834 
    None, # 0
16835 
    (1, TType.I64, 'providerId', None, None, ), # 1
16836 
  )
16837 
 
16838 
  def __init__(self, providerId=None,):
16839 
    self.providerId = providerId
16840 
 
16841 
  def read(self, iprot):
16842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16844 
      return
16845 
    iprot.readStructBegin()
16846 
    while True:
16847 
      (fname, ftype, fid) = iprot.readFieldBegin()
16848 
      if ftype == TType.STOP:
16849 
        break
16850 
      if fid == 1:
16851 
        if ftype == TType.I64:
16852 
          self.providerId = iprot.readI64();
16853 
        else:
16854 
          iprot.skip(ftype)
16855 
      else:
16856 
        iprot.skip(ftype)
16857 
      iprot.readFieldEnd()
16858 
    iprot.readStructEnd()
16859 
 
16860 
  def write(self, oprot):
16861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16863 
      return
16864 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
16865 
    if self.providerId is not None:
16866 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16867 
      oprot.writeI64(self.providerId)
16868 
      oprot.writeFieldEnd()
16869 
    oprot.writeFieldStop()
16870 
    oprot.writeStructEnd()
16871 
 
16872 
  def validate(self):
16873 
    return
16874 
 
16875 
 
16876 
  def __repr__(self):
16877 
    L = ['%s=%r' % (key, value)
16878 
      for key, value in self.__dict__.iteritems()]
16879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16880 
 
16881 
  def __eq__(self, other):
16882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16883 
 
16884 
  def __ne__(self, other):
16885 
    return not (self == other)
16886 
 
16887 
class getDoasNotPickedUp_result:
16888 
  """
16889 
  Attributes:
2764 chandransh 16890 
   - success
16891 
  """
16892 
 
16893 
  thrift_spec = (
16894 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16895 
  )
16896 
 
16897 
  def __init__(self, success=None,):
16898 
    self.success = success
16899 
 
16900 
  def read(self, iprot):
16901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16903 
      return
16904 
    iprot.readStructBegin()
16905 
    while True:
16906 
      (fname, ftype, fid) = iprot.readFieldBegin()
16907 
      if ftype == TType.STOP:
16908 
        break
16909 
      if fid == 0:
16910 
        if ftype == TType.LIST:
16911 
          self.success = []
6031 rajveer 16912 
          (_etype376, _size373) = iprot.readListBegin()
16913 
          for _i377 in xrange(_size373):
16914 
            _elem378 = Order()
16915 
            _elem378.read(iprot)
16916 
            self.success.append(_elem378)
2764 chandransh 16917 
          iprot.readListEnd()
16918 
        else:
16919 
          iprot.skip(ftype)
16920 
      else:
16921 
        iprot.skip(ftype)
16922 
      iprot.readFieldEnd()
16923 
    iprot.readStructEnd()
16924 
 
16925 
  def write(self, oprot):
16926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16928 
      return
4910 phani.kuma 16929 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 16930 
    if self.success is not None:
2764 chandransh 16931 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16932 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 16933 
      for iter379 in self.success:
16934 
        iter379.write(oprot)
2764 chandransh 16935 
      oprot.writeListEnd()
16936 
      oprot.writeFieldEnd()
16937 
    oprot.writeFieldStop()
16938 
    oprot.writeStructEnd()
16939 
 
3431 rajveer 16940 
  def validate(self):
16941 
    return
16942 
 
16943 
 
2764 chandransh 16944 
  def __repr__(self):
16945 
    L = ['%s=%r' % (key, value)
16946 
      for key, value in self.__dict__.iteritems()]
16947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16948 
 
16949 
  def __eq__(self, other):
16950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16951 
 
16952 
  def __ne__(self, other):
16953 
    return not (self == other)
16954 
 
4741 phani.kuma 16955 
class markReturnOrdersAsPickedUp_args:
16956 
  """
16957 
  Attributes:
16958 
   - providerId
16959 
   - pickupDetails
16960 
  """
16961 
 
16962 
  thrift_spec = (
16963 
    None, # 0
16964 
    (1, TType.I64, 'providerId', None, None, ), # 1
16965 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16966 
  )
16967 
 
16968 
  def __init__(self, providerId=None, pickupDetails=None,):
16969 
    self.providerId = providerId
16970 
    self.pickupDetails = pickupDetails
16971 
 
16972 
  def read(self, iprot):
16973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16975 
      return
16976 
    iprot.readStructBegin()
16977 
    while True:
16978 
      (fname, ftype, fid) = iprot.readFieldBegin()
16979 
      if ftype == TType.STOP:
16980 
        break
16981 
      if fid == 1:
16982 
        if ftype == TType.I64:
16983 
          self.providerId = iprot.readI64();
16984 
        else:
16985 
          iprot.skip(ftype)
16986 
      elif fid == 2:
16987 
        if ftype == TType.MAP:
16988 
          self.pickupDetails = {}
6031 rajveer 16989 
          (_ktype381, _vtype382, _size380 ) = iprot.readMapBegin()
16990 
          for _i384 in xrange(_size380):
16991 
            _key385 = iprot.readString();
16992 
            _val386 = iprot.readString();
16993 
            self.pickupDetails[_key385] = _val386
4741 phani.kuma 16994 
          iprot.readMapEnd()
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('markReturnOrdersAsPickedUp_args')
17007 
    if self.providerId is not None:
17008 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17009 
      oprot.writeI64(self.providerId)
17010 
      oprot.writeFieldEnd()
17011 
    if self.pickupDetails is not None:
17012 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17013 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 17014 
      for kiter387,viter388 in self.pickupDetails.items():
17015 
        oprot.writeString(kiter387)
17016 
        oprot.writeString(viter388)
4741 phani.kuma 17017 
      oprot.writeMapEnd()
17018 
      oprot.writeFieldEnd()
17019 
    oprot.writeFieldStop()
17020 
    oprot.writeStructEnd()
17021 
 
17022 
  def validate(self):
17023 
    return
17024 
 
17025 
 
17026 
  def __repr__(self):
17027 
    L = ['%s=%r' % (key, value)
17028 
      for key, value in self.__dict__.iteritems()]
17029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17030 
 
17031 
  def __eq__(self, other):
17032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17033 
 
17034 
  def __ne__(self, other):
17035 
    return not (self == other)
17036 
 
17037 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17038 
 
17039 
  thrift_spec = (
17040 
  )
17041 
 
17042 
  def read(self, iprot):
17043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17045 
      return
17046 
    iprot.readStructBegin()
17047 
    while True:
17048 
      (fname, ftype, fid) = iprot.readFieldBegin()
17049 
      if ftype == TType.STOP:
17050 
        break
17051 
      else:
17052 
        iprot.skip(ftype)
17053 
      iprot.readFieldEnd()
17054 
    iprot.readStructEnd()
17055 
 
17056 
  def write(self, oprot):
17057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17059 
      return
17060 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17061 
    oprot.writeFieldStop()
17062 
    oprot.writeStructEnd()
17063 
 
17064 
  def validate(self):
17065 
    return
17066 
 
17067 
 
17068 
  def __repr__(self):
17069 
    L = ['%s=%r' % (key, value)
17070 
      for key, value in self.__dict__.iteritems()]
17071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17072 
 
17073 
  def __eq__(self, other):
17074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17075 
 
17076 
  def __ne__(self, other):
17077 
    return not (self == other)
17078 
 
17079 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17080 
  """
17081 
  Attributes:
4910 phani.kuma 17082 
   - providerId
17083 
  """
17084 
 
17085 
  thrift_spec = (
17086 
    None, # 0
17087 
    (1, TType.I64, 'providerId', None, None, ), # 1
17088 
  )
17089 
 
17090 
  def __init__(self, providerId=None,):
17091 
    self.providerId = providerId
17092 
 
17093 
  def read(self, iprot):
17094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17096 
      return
17097 
    iprot.readStructBegin()
17098 
    while True:
17099 
      (fname, ftype, fid) = iprot.readFieldBegin()
17100 
      if ftype == TType.STOP:
17101 
        break
17102 
      if fid == 1:
17103 
        if ftype == TType.I64:
17104 
          self.providerId = iprot.readI64();
17105 
        else:
17106 
          iprot.skip(ftype)
17107 
      else:
17108 
        iprot.skip(ftype)
17109 
      iprot.readFieldEnd()
17110 
    iprot.readStructEnd()
17111 
 
17112 
  def write(self, oprot):
17113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17115 
      return
17116 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17117 
    if self.providerId is not None:
17118 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17119 
      oprot.writeI64(self.providerId)
17120 
      oprot.writeFieldEnd()
17121 
    oprot.writeFieldStop()
17122 
    oprot.writeStructEnd()
17123 
 
17124 
  def validate(self):
17125 
    return
17126 
 
17127 
 
17128 
  def __repr__(self):
17129 
    L = ['%s=%r' % (key, value)
17130 
      for key, value in self.__dict__.iteritems()]
17131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17132 
 
17133 
  def __eq__(self, other):
17134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17135 
 
17136 
  def __ne__(self, other):
17137 
    return not (self == other)
17138 
 
17139 
class getReturnOrdersNotPickedUp_result:
17140 
  """
17141 
  Attributes:
4741 phani.kuma 17142 
   - success
17143 
  """
17144 
 
17145 
  thrift_spec = (
17146 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17147 
  )
17148 
 
17149 
  def __init__(self, success=None,):
17150 
    self.success = success
17151 
 
17152 
  def read(self, iprot):
17153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17155 
      return
17156 
    iprot.readStructBegin()
17157 
    while True:
17158 
      (fname, ftype, fid) = iprot.readFieldBegin()
17159 
      if ftype == TType.STOP:
17160 
        break
17161 
      if fid == 0:
17162 
        if ftype == TType.LIST:
17163 
          self.success = []
6031 rajveer 17164 
          (_etype392, _size389) = iprot.readListBegin()
17165 
          for _i393 in xrange(_size389):
17166 
            _elem394 = Order()
17167 
            _elem394.read(iprot)
17168 
            self.success.append(_elem394)
4741 phani.kuma 17169 
          iprot.readListEnd()
17170 
        else:
17171 
          iprot.skip(ftype)
17172 
      else:
17173 
        iprot.skip(ftype)
17174 
      iprot.readFieldEnd()
17175 
    iprot.readStructEnd()
17176 
 
17177 
  def write(self, oprot):
17178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17180 
      return
4910 phani.kuma 17181 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17182 
    if self.success is not None:
17183 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17184 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17185 
      for iter395 in self.success:
17186 
        iter395.write(oprot)
4741 phani.kuma 17187 
      oprot.writeListEnd()
17188 
      oprot.writeFieldEnd()
17189 
    oprot.writeFieldStop()
17190 
    oprot.writeStructEnd()
17191 
 
17192 
  def validate(self):
17193 
    return
17194 
 
17195 
 
17196 
  def __repr__(self):
17197 
    L = ['%s=%r' % (key, value)
17198 
      for key, value in self.__dict__.iteritems()]
17199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17200 
 
17201 
  def __eq__(self, other):
17202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17203 
 
17204 
  def __ne__(self, other):
17205 
    return not (self == other)
17206 
 
2616 chandransh 17207 
class receiveReturn_args:
2591 chandransh 17208 
  """
17209 
  Attributes:
17210 
   - orderId
4479 rajveer 17211 
   - receiveCondition
2591 chandransh 17212 
  """
2536 chandransh 17213 
 
2591 chandransh 17214 
  thrift_spec = (
17215 
    None, # 0
17216 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17217 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17218 
  )
17219 
 
4479 rajveer 17220 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17221 
    self.orderId = orderId
4479 rajveer 17222 
    self.receiveCondition = receiveCondition
2591 chandransh 17223 
 
17224 
  def read(self, iprot):
17225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17227 
      return
17228 
    iprot.readStructBegin()
17229 
    while True:
17230 
      (fname, ftype, fid) = iprot.readFieldBegin()
17231 
      if ftype == TType.STOP:
17232 
        break
17233 
      if fid == 1:
17234 
        if ftype == TType.I64:
17235 
          self.orderId = iprot.readI64();
17236 
        else:
17237 
          iprot.skip(ftype)
4479 rajveer 17238 
      elif fid == 2:
17239 
        if ftype == TType.I64:
17240 
          self.receiveCondition = iprot.readI64();
17241 
        else:
17242 
          iprot.skip(ftype)
2591 chandransh 17243 
      else:
17244 
        iprot.skip(ftype)
17245 
      iprot.readFieldEnd()
17246 
    iprot.readStructEnd()
17247 
 
17248 
  def write(self, oprot):
17249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17251 
      return
2616 chandransh 17252 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17253 
    if self.orderId is not None:
2591 chandransh 17254 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17255 
      oprot.writeI64(self.orderId)
17256 
      oprot.writeFieldEnd()
4479 rajveer 17257 
    if self.receiveCondition is not None:
17258 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17259 
      oprot.writeI64(self.receiveCondition)
17260 
      oprot.writeFieldEnd()
2591 chandransh 17261 
    oprot.writeFieldStop()
17262 
    oprot.writeStructEnd()
17263 
 
3431 rajveer 17264 
  def validate(self):
17265 
    return
17266 
 
17267 
 
2591 chandransh 17268 
  def __repr__(self):
17269 
    L = ['%s=%r' % (key, value)
17270 
      for key, value in self.__dict__.iteritems()]
17271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17272 
 
17273 
  def __eq__(self, other):
17274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17275 
 
17276 
  def __ne__(self, other):
17277 
    return not (self == other)
17278 
 
2616 chandransh 17279 
class receiveReturn_result:
2591 chandransh 17280 
  """
17281 
  Attributes:
17282 
   - success
17283 
   - ex
17284 
  """
17285 
 
17286 
  thrift_spec = (
17287 
    (0, TType.BOOL, 'success', None, None, ), # 0
17288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17289 
  )
17290 
 
17291 
  def __init__(self, success=None, ex=None,):
17292 
    self.success = success
17293 
    self.ex = ex
17294 
 
17295 
  def read(self, iprot):
17296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17298 
      return
17299 
    iprot.readStructBegin()
17300 
    while True:
17301 
      (fname, ftype, fid) = iprot.readFieldBegin()
17302 
      if ftype == TType.STOP:
17303 
        break
17304 
      if fid == 0:
17305 
        if ftype == TType.BOOL:
17306 
          self.success = iprot.readBool();
17307 
        else:
17308 
          iprot.skip(ftype)
17309 
      elif fid == 1:
17310 
        if ftype == TType.STRUCT:
17311 
          self.ex = TransactionServiceException()
17312 
          self.ex.read(iprot)
17313 
        else:
17314 
          iprot.skip(ftype)
17315 
      else:
17316 
        iprot.skip(ftype)
17317 
      iprot.readFieldEnd()
17318 
    iprot.readStructEnd()
17319 
 
17320 
  def write(self, oprot):
17321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17323 
      return
2616 chandransh 17324 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17325 
    if self.success is not None:
2591 chandransh 17326 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17327 
      oprot.writeBool(self.success)
17328 
      oprot.writeFieldEnd()
3431 rajveer 17329 
    if self.ex is not None:
2591 chandransh 17330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17331 
      self.ex.write(oprot)
17332 
      oprot.writeFieldEnd()
17333 
    oprot.writeFieldStop()
17334 
    oprot.writeStructEnd()
17335 
 
3431 rajveer 17336 
  def validate(self):
17337 
    return
17338 
 
17339 
 
2591 chandransh 17340 
  def __repr__(self):
17341 
    L = ['%s=%r' % (key, value)
17342 
      for key, value in self.__dict__.iteritems()]
17343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17344 
 
17345 
  def __eq__(self, other):
17346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17347 
 
17348 
  def __ne__(self, other):
17349 
    return not (self == other)
17350 
 
17351 
class validateDoa_args:
17352 
  """
17353 
  Attributes:
17354 
   - orderId
17355 
   - isValid
17356 
  """
17357 
 
17358 
  thrift_spec = (
17359 
    None, # 0
17360 
    (1, TType.I64, 'orderId', None, None, ), # 1
17361 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17362 
  )
17363 
 
17364 
  def __init__(self, orderId=None, isValid=None,):
17365 
    self.orderId = orderId
17366 
    self.isValid = isValid
17367 
 
17368 
  def read(self, iprot):
17369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17371 
      return
17372 
    iprot.readStructBegin()
17373 
    while True:
17374 
      (fname, ftype, fid) = iprot.readFieldBegin()
17375 
      if ftype == TType.STOP:
17376 
        break
17377 
      if fid == 1:
17378 
        if ftype == TType.I64:
17379 
          self.orderId = iprot.readI64();
17380 
        else:
17381 
          iprot.skip(ftype)
17382 
      elif fid == 2:
17383 
        if ftype == TType.BOOL:
17384 
          self.isValid = iprot.readBool();
17385 
        else:
17386 
          iprot.skip(ftype)
17387 
      else:
17388 
        iprot.skip(ftype)
17389 
      iprot.readFieldEnd()
17390 
    iprot.readStructEnd()
17391 
 
17392 
  def write(self, oprot):
17393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17395 
      return
17396 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17397 
    if self.orderId is not None:
2591 chandransh 17398 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17399 
      oprot.writeI64(self.orderId)
17400 
      oprot.writeFieldEnd()
3431 rajveer 17401 
    if self.isValid is not None:
2591 chandransh 17402 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17403 
      oprot.writeBool(self.isValid)
17404 
      oprot.writeFieldEnd()
17405 
    oprot.writeFieldStop()
17406 
    oprot.writeStructEnd()
17407 
 
3431 rajveer 17408 
  def validate(self):
17409 
    return
17410 
 
17411 
 
2591 chandransh 17412 
  def __repr__(self):
17413 
    L = ['%s=%r' % (key, value)
17414 
      for key, value in self.__dict__.iteritems()]
17415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17416 
 
17417 
  def __eq__(self, other):
17418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17419 
 
17420 
  def __ne__(self, other):
17421 
    return not (self == other)
17422 
 
17423 
class validateDoa_result:
17424 
  """
17425 
  Attributes:
17426 
   - success
17427 
   - ex
17428 
  """
17429 
 
17430 
  thrift_spec = (
17431 
    (0, TType.BOOL, 'success', None, None, ), # 0
17432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17433 
  )
17434 
 
17435 
  def __init__(self, success=None, ex=None,):
17436 
    self.success = success
17437 
    self.ex = ex
17438 
 
17439 
  def read(self, iprot):
17440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17442 
      return
17443 
    iprot.readStructBegin()
17444 
    while True:
17445 
      (fname, ftype, fid) = iprot.readFieldBegin()
17446 
      if ftype == TType.STOP:
17447 
        break
17448 
      if fid == 0:
17449 
        if ftype == TType.BOOL:
17450 
          self.success = iprot.readBool();
17451 
        else:
17452 
          iprot.skip(ftype)
17453 
      elif fid == 1:
17454 
        if ftype == TType.STRUCT:
17455 
          self.ex = TransactionServiceException()
17456 
          self.ex.read(iprot)
17457 
        else:
17458 
          iprot.skip(ftype)
17459 
      else:
17460 
        iprot.skip(ftype)
17461 
      iprot.readFieldEnd()
17462 
    iprot.readStructEnd()
17463 
 
17464 
  def write(self, oprot):
17465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17467 
      return
17468 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17469 
    if self.success is not None:
2591 chandransh 17470 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17471 
      oprot.writeBool(self.success)
17472 
      oprot.writeFieldEnd()
3431 rajveer 17473 
    if self.ex is not None:
2591 chandransh 17474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17475 
      self.ex.write(oprot)
17476 
      oprot.writeFieldEnd()
17477 
    oprot.writeFieldStop()
17478 
    oprot.writeStructEnd()
17479 
 
3431 rajveer 17480 
  def validate(self):
17481 
    return
17482 
 
17483 
 
2591 chandransh 17484 
  def __repr__(self):
17485 
    L = ['%s=%r' % (key, value)
17486 
      for key, value in self.__dict__.iteritems()]
17487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17488 
 
17489 
  def __eq__(self, other):
17490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17491 
 
17492 
  def __ne__(self, other):
17493 
    return not (self == other)
17494 
 
4495 rajveer 17495 
class validateReturnProduct_args:
17496 
  """
17497 
  Attributes:
17498 
   - orderId
17499 
   - isUsable
17500 
  """
17501 
 
17502 
  thrift_spec = (
17503 
    None, # 0
17504 
    (1, TType.I64, 'orderId', None, None, ), # 1
17505 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17506 
  )
17507 
 
17508 
  def __init__(self, orderId=None, isUsable=None,):
17509 
    self.orderId = orderId
17510 
    self.isUsable = isUsable
17511 
 
17512 
  def read(self, iprot):
17513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17515 
      return
17516 
    iprot.readStructBegin()
17517 
    while True:
17518 
      (fname, ftype, fid) = iprot.readFieldBegin()
17519 
      if ftype == TType.STOP:
17520 
        break
17521 
      if fid == 1:
17522 
        if ftype == TType.I64:
17523 
          self.orderId = iprot.readI64();
17524 
        else:
17525 
          iprot.skip(ftype)
17526 
      elif fid == 2:
17527 
        if ftype == TType.BOOL:
17528 
          self.isUsable = iprot.readBool();
17529 
        else:
17530 
          iprot.skip(ftype)
17531 
      else:
17532 
        iprot.skip(ftype)
17533 
      iprot.readFieldEnd()
17534 
    iprot.readStructEnd()
17535 
 
17536 
  def write(self, oprot):
17537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17539 
      return
17540 
    oprot.writeStructBegin('validateReturnProduct_args')
17541 
    if self.orderId is not None:
17542 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17543 
      oprot.writeI64(self.orderId)
17544 
      oprot.writeFieldEnd()
17545 
    if self.isUsable is not None:
17546 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17547 
      oprot.writeBool(self.isUsable)
17548 
      oprot.writeFieldEnd()
17549 
    oprot.writeFieldStop()
17550 
    oprot.writeStructEnd()
17551 
 
17552 
  def validate(self):
17553 
    return
17554 
 
17555 
 
17556 
  def __repr__(self):
17557 
    L = ['%s=%r' % (key, value)
17558 
      for key, value in self.__dict__.iteritems()]
17559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17560 
 
17561 
  def __eq__(self, other):
17562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17563 
 
17564 
  def __ne__(self, other):
17565 
    return not (self == other)
17566 
 
17567 
class validateReturnProduct_result:
17568 
  """
17569 
  Attributes:
17570 
   - success
17571 
   - ex
17572 
  """
17573 
 
17574 
  thrift_spec = (
17575 
    (0, TType.BOOL, 'success', None, None, ), # 0
17576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17577 
  )
17578 
 
17579 
  def __init__(self, success=None, ex=None,):
17580 
    self.success = success
17581 
    self.ex = ex
17582 
 
17583 
  def read(self, iprot):
17584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17586 
      return
17587 
    iprot.readStructBegin()
17588 
    while True:
17589 
      (fname, ftype, fid) = iprot.readFieldBegin()
17590 
      if ftype == TType.STOP:
17591 
        break
17592 
      if fid == 0:
17593 
        if ftype == TType.BOOL:
17594 
          self.success = iprot.readBool();
17595 
        else:
17596 
          iprot.skip(ftype)
17597 
      elif fid == 1:
17598 
        if ftype == TType.STRUCT:
17599 
          self.ex = TransactionServiceException()
17600 
          self.ex.read(iprot)
17601 
        else:
17602 
          iprot.skip(ftype)
17603 
      else:
17604 
        iprot.skip(ftype)
17605 
      iprot.readFieldEnd()
17606 
    iprot.readStructEnd()
17607 
 
17608 
  def write(self, oprot):
17609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17611 
      return
17612 
    oprot.writeStructBegin('validateReturnProduct_result')
17613 
    if self.success is not None:
17614 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17615 
      oprot.writeBool(self.success)
17616 
      oprot.writeFieldEnd()
17617 
    if self.ex is not None:
17618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17619 
      self.ex.write(oprot)
17620 
      oprot.writeFieldEnd()
17621 
    oprot.writeFieldStop()
17622 
    oprot.writeStructEnd()
17623 
 
17624 
  def validate(self):
17625 
    return
17626 
 
17627 
 
17628 
  def __repr__(self):
17629 
    L = ['%s=%r' % (key, value)
17630 
      for key, value in self.__dict__.iteritems()]
17631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17632 
 
17633 
  def __eq__(self, other):
17634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17635 
 
17636 
  def __ne__(self, other):
17637 
    return not (self == other)
17638 
 
2616 chandransh 17639 
class reshipOrder_args:
17640 
  """
17641 
  Attributes:
17642 
   - orderId
17643 
  """
2591 chandransh 17644 
 
2616 chandransh 17645 
  thrift_spec = (
17646 
    None, # 0
17647 
    (1, TType.I64, 'orderId', None, None, ), # 1
17648 
  )
17649 
 
17650 
  def __init__(self, orderId=None,):
17651 
    self.orderId = orderId
17652 
 
17653 
  def read(self, iprot):
17654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17656 
      return
17657 
    iprot.readStructBegin()
17658 
    while True:
17659 
      (fname, ftype, fid) = iprot.readFieldBegin()
17660 
      if ftype == TType.STOP:
17661 
        break
17662 
      if fid == 1:
17663 
        if ftype == TType.I64:
17664 
          self.orderId = iprot.readI64();
17665 
        else:
17666 
          iprot.skip(ftype)
17667 
      else:
17668 
        iprot.skip(ftype)
17669 
      iprot.readFieldEnd()
17670 
    iprot.readStructEnd()
17671 
 
17672 
  def write(self, oprot):
17673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17675 
      return
17676 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17677 
    if self.orderId is not None:
2616 chandransh 17678 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17679 
      oprot.writeI64(self.orderId)
17680 
      oprot.writeFieldEnd()
17681 
    oprot.writeFieldStop()
17682 
    oprot.writeStructEnd()
17683 
 
3431 rajveer 17684 
  def validate(self):
17685 
    return
17686 
 
17687 
 
2616 chandransh 17688 
  def __repr__(self):
17689 
    L = ['%s=%r' % (key, value)
17690 
      for key, value in self.__dict__.iteritems()]
17691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17692 
 
17693 
  def __eq__(self, other):
17694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17695 
 
17696 
  def __ne__(self, other):
17697 
    return not (self == other)
17698 
 
17699 
class reshipOrder_result:
17700 
  """
17701 
  Attributes:
17702 
   - success
17703 
   - ex
17704 
  """
17705 
 
17706 
  thrift_spec = (
17707 
    (0, TType.I64, 'success', None, None, ), # 0
17708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17709 
  )
17710 
 
17711 
  def __init__(self, success=None, ex=None,):
17712 
    self.success = success
17713 
    self.ex = ex
17714 
 
17715 
  def read(self, iprot):
17716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17718 
      return
17719 
    iprot.readStructBegin()
17720 
    while True:
17721 
      (fname, ftype, fid) = iprot.readFieldBegin()
17722 
      if ftype == TType.STOP:
17723 
        break
17724 
      if fid == 0:
17725 
        if ftype == TType.I64:
17726 
          self.success = iprot.readI64();
17727 
        else:
17728 
          iprot.skip(ftype)
17729 
      elif fid == 1:
17730 
        if ftype == TType.STRUCT:
17731 
          self.ex = TransactionServiceException()
17732 
          self.ex.read(iprot)
17733 
        else:
17734 
          iprot.skip(ftype)
17735 
      else:
17736 
        iprot.skip(ftype)
17737 
      iprot.readFieldEnd()
17738 
    iprot.readStructEnd()
17739 
 
17740 
  def write(self, oprot):
17741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17743 
      return
17744 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17745 
    if self.success is not None:
2616 chandransh 17746 
      oprot.writeFieldBegin('success', TType.I64, 0)
17747 
      oprot.writeI64(self.success)
17748 
      oprot.writeFieldEnd()
3431 rajveer 17749 
    if self.ex is not None:
2616 chandransh 17750 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17751 
      self.ex.write(oprot)
17752 
      oprot.writeFieldEnd()
17753 
    oprot.writeFieldStop()
17754 
    oprot.writeStructEnd()
17755 
 
3431 rajveer 17756 
  def validate(self):
17757 
    return
17758 
 
17759 
 
2616 chandransh 17760 
  def __repr__(self):
17761 
    L = ['%s=%r' % (key, value)
17762 
      for key, value in self.__dict__.iteritems()]
17763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17764 
 
17765 
  def __eq__(self, other):
17766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17767 
 
17768 
  def __ne__(self, other):
17769 
    return not (self == other)
17770 
 
17771 
class refundOrder_args:
17772 
  """
17773 
  Attributes:
17774 
   - orderId
3226 chandransh 17775 
   - refundedBy
17776 
   - reason
2616 chandransh 17777 
  """
17778 
 
17779 
  thrift_spec = (
17780 
    None, # 0
17781 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17782 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17783 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17784 
  )
17785 
 
3226 chandransh 17786 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17787 
    self.orderId = orderId
3226 chandransh 17788 
    self.refundedBy = refundedBy
17789 
    self.reason = reason
2616 chandransh 17790 
 
17791 
  def read(self, iprot):
17792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17794 
      return
17795 
    iprot.readStructBegin()
17796 
    while True:
17797 
      (fname, ftype, fid) = iprot.readFieldBegin()
17798 
      if ftype == TType.STOP:
17799 
        break
17800 
      if fid == 1:
17801 
        if ftype == TType.I64:
17802 
          self.orderId = iprot.readI64();
17803 
        else:
17804 
          iprot.skip(ftype)
3226 chandransh 17805 
      elif fid == 2:
17806 
        if ftype == TType.STRING:
17807 
          self.refundedBy = iprot.readString();
17808 
        else:
17809 
          iprot.skip(ftype)
17810 
      elif fid == 3:
17811 
        if ftype == TType.STRING:
17812 
          self.reason = iprot.readString();
17813 
        else:
17814 
          iprot.skip(ftype)
2616 chandransh 17815 
      else:
17816 
        iprot.skip(ftype)
17817 
      iprot.readFieldEnd()
17818 
    iprot.readStructEnd()
17819 
 
17820 
  def write(self, oprot):
17821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17823 
      return
17824 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 17825 
    if self.orderId is not None:
2616 chandransh 17826 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17827 
      oprot.writeI64(self.orderId)
17828 
      oprot.writeFieldEnd()
3431 rajveer 17829 
    if self.refundedBy is not None:
3226 chandransh 17830 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17831 
      oprot.writeString(self.refundedBy)
17832 
      oprot.writeFieldEnd()
3431 rajveer 17833 
    if self.reason is not None:
3226 chandransh 17834 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17835 
      oprot.writeString(self.reason)
17836 
      oprot.writeFieldEnd()
2616 chandransh 17837 
    oprot.writeFieldStop()
17838 
    oprot.writeStructEnd()
17839 
 
3431 rajveer 17840 
  def validate(self):
17841 
    return
17842 
 
17843 
 
2616 chandransh 17844 
  def __repr__(self):
17845 
    L = ['%s=%r' % (key, value)
17846 
      for key, value in self.__dict__.iteritems()]
17847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17848 
 
17849 
  def __eq__(self, other):
17850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17851 
 
17852 
  def __ne__(self, other):
17853 
    return not (self == other)
17854 
 
17855 
class refundOrder_result:
17856 
  """
17857 
  Attributes:
17858 
   - success
17859 
   - ex
17860 
  """
17861 
 
17862 
  thrift_spec = (
17863 
    (0, TType.BOOL, 'success', None, None, ), # 0
17864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17865 
  )
17866 
 
17867 
  def __init__(self, success=None, ex=None,):
17868 
    self.success = success
17869 
    self.ex = ex
17870 
 
17871 
  def read(self, iprot):
17872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17874 
      return
17875 
    iprot.readStructBegin()
17876 
    while True:
17877 
      (fname, ftype, fid) = iprot.readFieldBegin()
17878 
      if ftype == TType.STOP:
17879 
        break
17880 
      if fid == 0:
17881 
        if ftype == TType.BOOL:
17882 
          self.success = iprot.readBool();
17883 
        else:
17884 
          iprot.skip(ftype)
17885 
      elif fid == 1:
17886 
        if ftype == TType.STRUCT:
17887 
          self.ex = TransactionServiceException()
17888 
          self.ex.read(iprot)
17889 
        else:
17890 
          iprot.skip(ftype)
17891 
      else:
17892 
        iprot.skip(ftype)
17893 
      iprot.readFieldEnd()
17894 
    iprot.readStructEnd()
17895 
 
17896 
  def write(self, oprot):
17897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17899 
      return
17900 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 17901 
    if self.success is not None:
2616 chandransh 17902 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17903 
      oprot.writeBool(self.success)
17904 
      oprot.writeFieldEnd()
3431 rajveer 17905 
    if self.ex is not None:
2616 chandransh 17906 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17907 
      self.ex.write(oprot)
17908 
      oprot.writeFieldEnd()
17909 
    oprot.writeFieldStop()
17910 
    oprot.writeStructEnd()
17911 
 
3431 rajveer 17912 
  def validate(self):
17913 
    return
17914 
 
17915 
 
2616 chandransh 17916 
  def __repr__(self):
17917 
    L = ['%s=%r' % (key, value)
17918 
      for key, value in self.__dict__.iteritems()]
17919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17920 
 
17921 
  def __eq__(self, other):
17922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17923 
 
17924 
  def __ne__(self, other):
17925 
    return not (self == other)
17926 
 
2690 chandransh 17927 
class getReturnOrders_args:
17928 
  """
17929 
  Attributes:
17930 
   - warehouseId
17931 
   - fromDate
17932 
   - toDate
17933 
  """
2616 chandransh 17934 
 
2690 chandransh 17935 
  thrift_spec = (
17936 
    None, # 0
17937 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
17938 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17939 
    (3, TType.I64, 'toDate', None, None, ), # 3
17940 
  )
17941 
 
17942 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
17943 
    self.warehouseId = warehouseId
17944 
    self.fromDate = fromDate
17945 
    self.toDate = toDate
17946 
 
17947 
  def read(self, iprot):
17948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17950 
      return
17951 
    iprot.readStructBegin()
17952 
    while True:
17953 
      (fname, ftype, fid) = iprot.readFieldBegin()
17954 
      if ftype == TType.STOP:
17955 
        break
17956 
      if fid == 1:
17957 
        if ftype == TType.I64:
17958 
          self.warehouseId = iprot.readI64();
17959 
        else:
17960 
          iprot.skip(ftype)
17961 
      elif fid == 2:
17962 
        if ftype == TType.I64:
17963 
          self.fromDate = iprot.readI64();
17964 
        else:
17965 
          iprot.skip(ftype)
17966 
      elif fid == 3:
17967 
        if ftype == TType.I64:
17968 
          self.toDate = iprot.readI64();
17969 
        else:
17970 
          iprot.skip(ftype)
17971 
      else:
17972 
        iprot.skip(ftype)
17973 
      iprot.readFieldEnd()
17974 
    iprot.readStructEnd()
17975 
 
17976 
  def write(self, oprot):
17977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17979 
      return
17980 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17981 
    if self.warehouseId is not None:
2690 chandransh 17982 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17983 
      oprot.writeI64(self.warehouseId)
17984 
      oprot.writeFieldEnd()
3431 rajveer 17985 
    if self.fromDate is not None:
2690 chandransh 17986 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17987 
      oprot.writeI64(self.fromDate)
17988 
      oprot.writeFieldEnd()
3431 rajveer 17989 
    if self.toDate is not None:
2690 chandransh 17990 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17991 
      oprot.writeI64(self.toDate)
17992 
      oprot.writeFieldEnd()
17993 
    oprot.writeFieldStop()
17994 
    oprot.writeStructEnd()
17995 
 
3431 rajveer 17996 
  def validate(self):
17997 
    return
17998 
 
17999 
 
2690 chandransh 18000 
  def __repr__(self):
18001 
    L = ['%s=%r' % (key, value)
18002 
      for key, value in self.__dict__.iteritems()]
18003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18004 
 
18005 
  def __eq__(self, other):
18006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18007 
 
18008 
  def __ne__(self, other):
18009 
    return not (self == other)
18010 
 
18011 
class getReturnOrders_result:
18012 
  """
18013 
  Attributes:
18014 
   - success
18015 
  """
18016 
 
18017 
  thrift_spec = (
18018 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18019 
  )
18020 
 
18021 
  def __init__(self, success=None,):
18022 
    self.success = success
18023 
 
18024 
  def read(self, iprot):
18025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18027 
      return
18028 
    iprot.readStructBegin()
18029 
    while True:
18030 
      (fname, ftype, fid) = iprot.readFieldBegin()
18031 
      if ftype == TType.STOP:
18032 
        break
18033 
      if fid == 0:
18034 
        if ftype == TType.LIST:
18035 
          self.success = []
6031 rajveer 18036 
          (_etype399, _size396) = iprot.readListBegin()
18037 
          for _i400 in xrange(_size396):
18038 
            _elem401 = ReturnOrder()
18039 
            _elem401.read(iprot)
18040 
            self.success.append(_elem401)
2690 chandransh 18041 
          iprot.readListEnd()
18042 
        else:
18043 
          iprot.skip(ftype)
18044 
      else:
18045 
        iprot.skip(ftype)
18046 
      iprot.readFieldEnd()
18047 
    iprot.readStructEnd()
18048 
 
18049 
  def write(self, oprot):
18050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18052 
      return
18053 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18054 
    if self.success is not None:
2690 chandransh 18055 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18056 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18057 
      for iter402 in self.success:
18058 
        iter402.write(oprot)
2690 chandransh 18059 
      oprot.writeListEnd()
18060 
      oprot.writeFieldEnd()
18061 
    oprot.writeFieldStop()
18062 
    oprot.writeStructEnd()
18063 
 
3431 rajveer 18064 
  def validate(self):
18065 
    return
18066 
 
18067 
 
2690 chandransh 18068 
  def __repr__(self):
18069 
    L = ['%s=%r' % (key, value)
18070 
      for key, value in self.__dict__.iteritems()]
18071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18072 
 
18073 
  def __eq__(self, other):
18074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18075 
 
18076 
  def __ne__(self, other):
18077 
    return not (self == other)
18078 
 
5481 phani.kuma 18079 
class getAllReturnOrders_args:
18080 
  """
18081 
  Attributes:
18082 
   - onlyNotProcessed
18083 
   - fromDate
18084 
   - toDate
18085 
  """
18086 
 
18087 
  thrift_spec = (
18088 
    None, # 0
18089 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18090 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18091 
    (3, TType.I64, 'toDate', None, None, ), # 3
18092 
  )
18093 
 
18094 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18095 
    self.onlyNotProcessed = onlyNotProcessed
18096 
    self.fromDate = fromDate
18097 
    self.toDate = toDate
18098 
 
18099 
  def read(self, iprot):
18100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18102 
      return
18103 
    iprot.readStructBegin()
18104 
    while True:
18105 
      (fname, ftype, fid) = iprot.readFieldBegin()
18106 
      if ftype == TType.STOP:
18107 
        break
18108 
      if fid == 1:
18109 
        if ftype == TType.BOOL:
18110 
          self.onlyNotProcessed = iprot.readBool();
18111 
        else:
18112 
          iprot.skip(ftype)
18113 
      elif fid == 2:
18114 
        if ftype == TType.I64:
18115 
          self.fromDate = iprot.readI64();
18116 
        else:
18117 
          iprot.skip(ftype)
18118 
      elif fid == 3:
18119 
        if ftype == TType.I64:
18120 
          self.toDate = 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('getAllReturnOrders_args')
18133 
    if self.onlyNotProcessed is not None:
18134 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18135 
      oprot.writeBool(self.onlyNotProcessed)
18136 
      oprot.writeFieldEnd()
18137 
    if self.fromDate is not None:
18138 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18139 
      oprot.writeI64(self.fromDate)
18140 
      oprot.writeFieldEnd()
18141 
    if self.toDate is not None:
18142 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18143 
      oprot.writeI64(self.toDate)
18144 
      oprot.writeFieldEnd()
18145 
    oprot.writeFieldStop()
18146 
    oprot.writeStructEnd()
18147 
 
18148 
  def validate(self):
18149 
    return
18150 
 
18151 
 
18152 
  def __repr__(self):
18153 
    L = ['%s=%r' % (key, value)
18154 
      for key, value in self.__dict__.iteritems()]
18155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18156 
 
18157 
  def __eq__(self, other):
18158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18159 
 
18160 
  def __ne__(self, other):
18161 
    return not (self == other)
18162 
 
18163 
class getAllReturnOrders_result:
18164 
  """
18165 
  Attributes:
18166 
   - success
18167 
  """
18168 
 
18169 
  thrift_spec = (
18170 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18171 
  )
18172 
 
18173 
  def __init__(self, success=None,):
18174 
    self.success = success
18175 
 
18176 
  def read(self, iprot):
18177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18179 
      return
18180 
    iprot.readStructBegin()
18181 
    while True:
18182 
      (fname, ftype, fid) = iprot.readFieldBegin()
18183 
      if ftype == TType.STOP:
18184 
        break
18185 
      if fid == 0:
18186 
        if ftype == TType.LIST:
18187 
          self.success = []
6031 rajveer 18188 
          (_etype406, _size403) = iprot.readListBegin()
18189 
          for _i407 in xrange(_size403):
18190 
            _elem408 = ReturnOrder()
18191 
            _elem408.read(iprot)
18192 
            self.success.append(_elem408)
5481 phani.kuma 18193 
          iprot.readListEnd()
18194 
        else:
18195 
          iprot.skip(ftype)
18196 
      else:
18197 
        iprot.skip(ftype)
18198 
      iprot.readFieldEnd()
18199 
    iprot.readStructEnd()
18200 
 
18201 
  def write(self, oprot):
18202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18204 
      return
18205 
    oprot.writeStructBegin('getAllReturnOrders_result')
18206 
    if self.success is not None:
18207 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18208 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18209 
      for iter409 in self.success:
18210 
        iter409.write(oprot)
5481 phani.kuma 18211 
      oprot.writeListEnd()
18212 
      oprot.writeFieldEnd()
18213 
    oprot.writeFieldStop()
18214 
    oprot.writeStructEnd()
18215 
 
18216 
  def validate(self):
18217 
    return
18218 
 
18219 
 
18220 
  def __repr__(self):
18221 
    L = ['%s=%r' % (key, value)
18222 
      for key, value in self.__dict__.iteritems()]
18223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18224 
 
18225 
  def __eq__(self, other):
18226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18227 
 
18228 
  def __ne__(self, other):
18229 
    return not (self == other)
18230 
 
2700 chandransh 18231 
class getReturnOrder_args:
18232 
  """
18233 
  Attributes:
18234 
   - id
18235 
  """
18236 
 
18237 
  thrift_spec = (
18238 
    None, # 0
18239 
    (1, TType.I64, 'id', None, None, ), # 1
18240 
  )
18241 
 
18242 
  def __init__(self, id=None,):
18243 
    self.id = id
18244 
 
18245 
  def read(self, iprot):
18246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18248 
      return
18249 
    iprot.readStructBegin()
18250 
    while True:
18251 
      (fname, ftype, fid) = iprot.readFieldBegin()
18252 
      if ftype == TType.STOP:
18253 
        break
18254 
      if fid == 1:
18255 
        if ftype == TType.I64:
18256 
          self.id = iprot.readI64();
18257 
        else:
18258 
          iprot.skip(ftype)
18259 
      else:
18260 
        iprot.skip(ftype)
18261 
      iprot.readFieldEnd()
18262 
    iprot.readStructEnd()
18263 
 
18264 
  def write(self, oprot):
18265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18267 
      return
18268 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18269 
    if self.id is not None:
2700 chandransh 18270 
      oprot.writeFieldBegin('id', TType.I64, 1)
18271 
      oprot.writeI64(self.id)
18272 
      oprot.writeFieldEnd()
18273 
    oprot.writeFieldStop()
18274 
    oprot.writeStructEnd()
18275 
 
3431 rajveer 18276 
  def validate(self):
18277 
    return
18278 
 
18279 
 
2700 chandransh 18280 
  def __repr__(self):
18281 
    L = ['%s=%r' % (key, value)
18282 
      for key, value in self.__dict__.iteritems()]
18283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18284 
 
18285 
  def __eq__(self, other):
18286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18287 
 
18288 
  def __ne__(self, other):
18289 
    return not (self == other)
18290 
 
18291 
class getReturnOrder_result:
18292 
  """
18293 
  Attributes:
18294 
   - success
18295 
   - ex
18296 
  """
18297 
 
18298 
  thrift_spec = (
18299 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18301 
  )
18302 
 
18303 
  def __init__(self, success=None, ex=None,):
18304 
    self.success = success
18305 
    self.ex = ex
18306 
 
18307 
  def read(self, iprot):
18308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18310 
      return
18311 
    iprot.readStructBegin()
18312 
    while True:
18313 
      (fname, ftype, fid) = iprot.readFieldBegin()
18314 
      if ftype == TType.STOP:
18315 
        break
18316 
      if fid == 0:
18317 
        if ftype == TType.STRUCT:
18318 
          self.success = ReturnOrder()
18319 
          self.success.read(iprot)
18320 
        else:
18321 
          iprot.skip(ftype)
18322 
      elif fid == 1:
18323 
        if ftype == TType.STRUCT:
18324 
          self.ex = TransactionServiceException()
18325 
          self.ex.read(iprot)
18326 
        else:
18327 
          iprot.skip(ftype)
18328 
      else:
18329 
        iprot.skip(ftype)
18330 
      iprot.readFieldEnd()
18331 
    iprot.readStructEnd()
18332 
 
18333 
  def write(self, oprot):
18334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18336 
      return
18337 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18338 
    if self.success is not None:
2700 chandransh 18339 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18340 
      self.success.write(oprot)
18341 
      oprot.writeFieldEnd()
3431 rajveer 18342 
    if self.ex is not None:
2700 chandransh 18343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18344 
      self.ex.write(oprot)
18345 
      oprot.writeFieldEnd()
18346 
    oprot.writeFieldStop()
18347 
    oprot.writeStructEnd()
18348 
 
3431 rajveer 18349 
  def validate(self):
18350 
    return
18351 
 
18352 
 
2700 chandransh 18353 
  def __repr__(self):
18354 
    L = ['%s=%r' % (key, value)
18355 
      for key, value in self.__dict__.iteritems()]
18356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18357 
 
18358 
  def __eq__(self, other):
18359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18360 
 
18361 
  def __ne__(self, other):
18362 
    return not (self == other)
18363 
 
2690 chandransh 18364 
class processReturn_args:
18365 
  """
18366 
  Attributes:
18367 
   - returnOrderId
18368 
  """
18369 
 
18370 
  thrift_spec = (
18371 
    None, # 0
18372 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18373 
  )
18374 
 
18375 
  def __init__(self, returnOrderId=None,):
18376 
    self.returnOrderId = returnOrderId
18377 
 
18378 
  def read(self, iprot):
18379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18381 
      return
18382 
    iprot.readStructBegin()
18383 
    while True:
18384 
      (fname, ftype, fid) = iprot.readFieldBegin()
18385 
      if ftype == TType.STOP:
18386 
        break
18387 
      if fid == 1:
18388 
        if ftype == TType.I64:
18389 
          self.returnOrderId = iprot.readI64();
18390 
        else:
18391 
          iprot.skip(ftype)
18392 
      else:
18393 
        iprot.skip(ftype)
18394 
      iprot.readFieldEnd()
18395 
    iprot.readStructEnd()
18396 
 
18397 
  def write(self, oprot):
18398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18400 
      return
18401 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18402 
    if self.returnOrderId is not None:
2690 chandransh 18403 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18404 
      oprot.writeI64(self.returnOrderId)
18405 
      oprot.writeFieldEnd()
18406 
    oprot.writeFieldStop()
18407 
    oprot.writeStructEnd()
18408 
 
3431 rajveer 18409 
  def validate(self):
18410 
    return
18411 
 
18412 
 
2690 chandransh 18413 
  def __repr__(self):
18414 
    L = ['%s=%r' % (key, value)
18415 
      for key, value in self.__dict__.iteritems()]
18416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18417 
 
18418 
  def __eq__(self, other):
18419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18420 
 
18421 
  def __ne__(self, other):
18422 
    return not (self == other)
18423 
 
18424 
class processReturn_result:
18425 
  """
18426 
  Attributes:
18427 
   - ex
18428 
  """
18429 
 
18430 
  thrift_spec = (
18431 
    None, # 0
18432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18433 
  )
18434 
 
18435 
  def __init__(self, ex=None,):
18436 
    self.ex = ex
18437 
 
18438 
  def read(self, iprot):
18439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18441 
      return
18442 
    iprot.readStructBegin()
18443 
    while True:
18444 
      (fname, ftype, fid) = iprot.readFieldBegin()
18445 
      if ftype == TType.STOP:
18446 
        break
18447 
      if fid == 1:
18448 
        if ftype == TType.STRUCT:
18449 
          self.ex = TransactionServiceException()
18450 
          self.ex.read(iprot)
18451 
        else:
18452 
          iprot.skip(ftype)
18453 
      else:
18454 
        iprot.skip(ftype)
18455 
      iprot.readFieldEnd()
18456 
    iprot.readStructEnd()
18457 
 
18458 
  def write(self, oprot):
18459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18461 
      return
18462 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18463 
    if self.ex is not None:
2690 chandransh 18464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18465 
      self.ex.write(oprot)
18466 
      oprot.writeFieldEnd()
18467 
    oprot.writeFieldStop()
18468 
    oprot.writeStructEnd()
18469 
 
3431 rajveer 18470 
  def validate(self):
18471 
    return
18472 
 
18473 
 
2690 chandransh 18474 
  def __repr__(self):
18475 
    L = ['%s=%r' % (key, value)
18476 
      for key, value in self.__dict__.iteritems()]
18477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18478 
 
18479 
  def __eq__(self, other):
18480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18481 
 
18482 
  def __ne__(self, other):
18483 
    return not (self == other)
18484 
 
3451 chandransh 18485 
class updateWeight_args:
18486 
  """
18487 
  Attributes:
18488 
   - orderId
18489 
   - weight
18490 
  """
18491 
 
18492 
  thrift_spec = (
18493 
    None, # 0
18494 
    (1, TType.I64, 'orderId', None, None, ), # 1
18495 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18496 
  )
18497 
 
18498 
  def __init__(self, orderId=None, weight=None,):
18499 
    self.orderId = orderId
18500 
    self.weight = weight
18501 
 
18502 
  def read(self, iprot):
18503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18505 
      return
18506 
    iprot.readStructBegin()
18507 
    while True:
18508 
      (fname, ftype, fid) = iprot.readFieldBegin()
18509 
      if ftype == TType.STOP:
18510 
        break
18511 
      if fid == 1:
18512 
        if ftype == TType.I64:
18513 
          self.orderId = iprot.readI64();
18514 
        else:
18515 
          iprot.skip(ftype)
18516 
      elif fid == 2:
18517 
        if ftype == TType.DOUBLE:
18518 
          self.weight = iprot.readDouble();
18519 
        else:
18520 
          iprot.skip(ftype)
18521 
      else:
18522 
        iprot.skip(ftype)
18523 
      iprot.readFieldEnd()
18524 
    iprot.readStructEnd()
18525 
 
18526 
  def write(self, oprot):
18527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18529 
      return
18530 
    oprot.writeStructBegin('updateWeight_args')
18531 
    if self.orderId is not None:
18532 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18533 
      oprot.writeI64(self.orderId)
18534 
      oprot.writeFieldEnd()
18535 
    if self.weight is not None:
18536 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18537 
      oprot.writeDouble(self.weight)
18538 
      oprot.writeFieldEnd()
18539 
    oprot.writeFieldStop()
18540 
    oprot.writeStructEnd()
18541 
 
18542 
  def validate(self):
18543 
    return
18544 
 
18545 
 
18546 
  def __repr__(self):
18547 
    L = ['%s=%r' % (key, value)
18548 
      for key, value in self.__dict__.iteritems()]
18549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18550 
 
18551 
  def __eq__(self, other):
18552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18553 
 
18554 
  def __ne__(self, other):
18555 
    return not (self == other)
18556 
 
18557 
class updateWeight_result:
18558 
  """
18559 
  Attributes:
18560 
   - success
18561 
   - ex
18562 
  """
18563 
 
18564 
  thrift_spec = (
18565 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18567 
  )
18568 
 
18569 
  def __init__(self, success=None, ex=None,):
18570 
    self.success = success
18571 
    self.ex = ex
18572 
 
18573 
  def read(self, iprot):
18574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18576 
      return
18577 
    iprot.readStructBegin()
18578 
    while True:
18579 
      (fname, ftype, fid) = iprot.readFieldBegin()
18580 
      if ftype == TType.STOP:
18581 
        break
18582 
      if fid == 0:
18583 
        if ftype == TType.STRUCT:
18584 
          self.success = Order()
18585 
          self.success.read(iprot)
18586 
        else:
18587 
          iprot.skip(ftype)
18588 
      elif fid == 1:
18589 
        if ftype == TType.STRUCT:
18590 
          self.ex = TransactionServiceException()
18591 
          self.ex.read(iprot)
18592 
        else:
18593 
          iprot.skip(ftype)
18594 
      else:
18595 
        iprot.skip(ftype)
18596 
      iprot.readFieldEnd()
18597 
    iprot.readStructEnd()
18598 
 
18599 
  def write(self, oprot):
18600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18602 
      return
18603 
    oprot.writeStructBegin('updateWeight_result')
18604 
    if self.success is not None:
18605 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18606 
      self.success.write(oprot)
18607 
      oprot.writeFieldEnd()
18608 
    if self.ex is not None:
18609 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18610 
      self.ex.write(oprot)
18611 
      oprot.writeFieldEnd()
18612 
    oprot.writeFieldStop()
18613 
    oprot.writeStructEnd()
18614 
 
18615 
  def validate(self):
18616 
    return
18617 
 
18618 
 
18619 
  def __repr__(self):
18620 
    L = ['%s=%r' % (key, value)
18621 
      for key, value in self.__dict__.iteritems()]
18622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18623 
 
18624 
  def __eq__(self, other):
18625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18626 
 
18627 
  def __ne__(self, other):
18628 
    return not (self == other)
3469 chandransh 18629 
 
18630 
class changeItem_args:
18631 
  """
18632 
  Attributes:
18633 
   - orderId
18634 
   - itemId
18635 
  """
18636 
 
18637 
  thrift_spec = (
18638 
    None, # 0
18639 
    (1, TType.I64, 'orderId', None, None, ), # 1
18640 
    (2, TType.I64, 'itemId', None, None, ), # 2
18641 
  )
18642 
 
18643 
  def __init__(self, orderId=None, itemId=None,):
18644 
    self.orderId = orderId
18645 
    self.itemId = itemId
18646 
 
18647 
  def read(self, iprot):
18648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18650 
      return
18651 
    iprot.readStructBegin()
18652 
    while True:
18653 
      (fname, ftype, fid) = iprot.readFieldBegin()
18654 
      if ftype == TType.STOP:
18655 
        break
18656 
      if fid == 1:
18657 
        if ftype == TType.I64:
18658 
          self.orderId = iprot.readI64();
18659 
        else:
18660 
          iprot.skip(ftype)
18661 
      elif fid == 2:
18662 
        if ftype == TType.I64:
18663 
          self.itemId = iprot.readI64();
18664 
        else:
18665 
          iprot.skip(ftype)
18666 
      else:
18667 
        iprot.skip(ftype)
18668 
      iprot.readFieldEnd()
18669 
    iprot.readStructEnd()
18670 
 
18671 
  def write(self, oprot):
18672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18674 
      return
18675 
    oprot.writeStructBegin('changeItem_args')
18676 
    if self.orderId is not None:
18677 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18678 
      oprot.writeI64(self.orderId)
18679 
      oprot.writeFieldEnd()
18680 
    if self.itemId is not None:
18681 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18682 
      oprot.writeI64(self.itemId)
18683 
      oprot.writeFieldEnd()
18684 
    oprot.writeFieldStop()
18685 
    oprot.writeStructEnd()
18686 
 
18687 
  def validate(self):
18688 
    return
18689 
 
18690 
 
18691 
  def __repr__(self):
18692 
    L = ['%s=%r' % (key, value)
18693 
      for key, value in self.__dict__.iteritems()]
18694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18695 
 
18696 
  def __eq__(self, other):
18697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18698 
 
18699 
  def __ne__(self, other):
18700 
    return not (self == other)
18701 
 
18702 
class changeItem_result:
18703 
  """
18704 
  Attributes:
18705 
   - success
18706 
   - ex
18707 
  """
18708 
 
18709 
  thrift_spec = (
18710 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18711 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18712 
  )
18713 
 
18714 
  def __init__(self, success=None, ex=None,):
18715 
    self.success = success
18716 
    self.ex = ex
18717 
 
18718 
  def read(self, iprot):
18719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18721 
      return
18722 
    iprot.readStructBegin()
18723 
    while True:
18724 
      (fname, ftype, fid) = iprot.readFieldBegin()
18725 
      if ftype == TType.STOP:
18726 
        break
18727 
      if fid == 0:
18728 
        if ftype == TType.STRUCT:
18729 
          self.success = Order()
18730 
          self.success.read(iprot)
18731 
        else:
18732 
          iprot.skip(ftype)
18733 
      elif fid == 1:
18734 
        if ftype == TType.STRUCT:
18735 
          self.ex = TransactionServiceException()
18736 
          self.ex.read(iprot)
18737 
        else:
18738 
          iprot.skip(ftype)
18739 
      else:
18740 
        iprot.skip(ftype)
18741 
      iprot.readFieldEnd()
18742 
    iprot.readStructEnd()
18743 
 
18744 
  def write(self, oprot):
18745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18747 
      return
18748 
    oprot.writeStructBegin('changeItem_result')
18749 
    if self.success is not None:
18750 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18751 
      self.success.write(oprot)
18752 
      oprot.writeFieldEnd()
18753 
    if self.ex is not None:
18754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18755 
      self.ex.write(oprot)
18756 
      oprot.writeFieldEnd()
18757 
    oprot.writeFieldStop()
18758 
    oprot.writeStructEnd()
18759 
 
18760 
  def validate(self):
18761 
    return
18762 
 
18763 
 
18764 
  def __repr__(self):
18765 
    L = ['%s=%r' % (key, value)
18766 
      for key, value in self.__dict__.iteritems()]
18767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18768 
 
18769 
  def __eq__(self, other):
18770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18771 
 
18772 
  def __ne__(self, other):
18773 
    return not (self == other)
18774 
 
18775 
class shiftToWarehouse_args:
18776 
  """
18777 
  Attributes:
18778 
   - orderId
18779 
   - warehouseId
18780 
  """
18781 
 
18782 
  thrift_spec = (
18783 
    None, # 0
18784 
    (1, TType.I64, 'orderId', None, None, ), # 1
18785 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18786 
  )
18787 
 
18788 
  def __init__(self, orderId=None, warehouseId=None,):
18789 
    self.orderId = orderId
18790 
    self.warehouseId = warehouseId
18791 
 
18792 
  def read(self, iprot):
18793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18795 
      return
18796 
    iprot.readStructBegin()
18797 
    while True:
18798 
      (fname, ftype, fid) = iprot.readFieldBegin()
18799 
      if ftype == TType.STOP:
18800 
        break
18801 
      if fid == 1:
18802 
        if ftype == TType.I64:
18803 
          self.orderId = iprot.readI64();
18804 
        else:
18805 
          iprot.skip(ftype)
18806 
      elif fid == 2:
18807 
        if ftype == TType.I64:
18808 
          self.warehouseId = iprot.readI64();
18809 
        else:
18810 
          iprot.skip(ftype)
18811 
      else:
18812 
        iprot.skip(ftype)
18813 
      iprot.readFieldEnd()
18814 
    iprot.readStructEnd()
18815 
 
18816 
  def write(self, oprot):
18817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18819 
      return
18820 
    oprot.writeStructBegin('shiftToWarehouse_args')
18821 
    if self.orderId is not None:
18822 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18823 
      oprot.writeI64(self.orderId)
18824 
      oprot.writeFieldEnd()
18825 
    if self.warehouseId is not None:
18826 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18827 
      oprot.writeI64(self.warehouseId)
18828 
      oprot.writeFieldEnd()
18829 
    oprot.writeFieldStop()
18830 
    oprot.writeStructEnd()
18831 
 
18832 
  def validate(self):
18833 
    return
18834 
 
18835 
 
18836 
  def __repr__(self):
18837 
    L = ['%s=%r' % (key, value)
18838 
      for key, value in self.__dict__.iteritems()]
18839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18840 
 
18841 
  def __eq__(self, other):
18842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18843 
 
18844 
  def __ne__(self, other):
18845 
    return not (self == other)
18846 
 
18847 
class shiftToWarehouse_result:
18848 
  """
18849 
  Attributes:
18850 
   - success
18851 
   - ex
18852 
  """
18853 
 
18854 
  thrift_spec = (
18855 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18856 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18857 
  )
18858 
 
18859 
  def __init__(self, success=None, ex=None,):
18860 
    self.success = success
18861 
    self.ex = ex
18862 
 
18863 
  def read(self, iprot):
18864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18866 
      return
18867 
    iprot.readStructBegin()
18868 
    while True:
18869 
      (fname, ftype, fid) = iprot.readFieldBegin()
18870 
      if ftype == TType.STOP:
18871 
        break
18872 
      if fid == 0:
18873 
        if ftype == TType.STRUCT:
18874 
          self.success = Order()
18875 
          self.success.read(iprot)
18876 
        else:
18877 
          iprot.skip(ftype)
18878 
      elif fid == 1:
18879 
        if ftype == TType.STRUCT:
18880 
          self.ex = TransactionServiceException()
18881 
          self.ex.read(iprot)
18882 
        else:
18883 
          iprot.skip(ftype)
18884 
      else:
18885 
        iprot.skip(ftype)
18886 
      iprot.readFieldEnd()
18887 
    iprot.readStructEnd()
18888 
 
18889 
  def write(self, oprot):
18890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18892 
      return
18893 
    oprot.writeStructBegin('shiftToWarehouse_result')
18894 
    if self.success is not None:
18895 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18896 
      self.success.write(oprot)
18897 
      oprot.writeFieldEnd()
18898 
    if self.ex is not None:
18899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18900 
      self.ex.write(oprot)
18901 
      oprot.writeFieldEnd()
18902 
    oprot.writeFieldStop()
18903 
    oprot.writeStructEnd()
18904 
 
18905 
  def validate(self):
18906 
    return
18907 
 
18908 
 
18909 
  def __repr__(self):
18910 
    L = ['%s=%r' % (key, value)
18911 
      for key, value in self.__dict__.iteritems()]
18912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18913 
 
18914 
  def __eq__(self, other):
18915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18916 
 
18917 
  def __ne__(self, other):
18918 
    return not (self == other)
3553 chandransh 18919 
 
18920 
class addDelayReason_args:
18921 
  """
18922 
  Attributes:
18923 
   - orderId
18924 
   - delayReason
3986 chandransh 18925 
   - furtherDelay
4647 rajveer 18926 
   - delayReasonText
3553 chandransh 18927 
  """
18928 
 
18929 
  thrift_spec = (
18930 
    None, # 0
18931 
    (1, TType.I64, 'orderId', None, None, ), # 1
18932 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 18933 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 18934 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 18935 
  )
18936 
 
4647 rajveer 18937 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 18938 
    self.orderId = orderId
18939 
    self.delayReason = delayReason
3986 chandransh 18940 
    self.furtherDelay = furtherDelay
4647 rajveer 18941 
    self.delayReasonText = delayReasonText
3553 chandransh 18942 
 
18943 
  def read(self, iprot):
18944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18946 
      return
18947 
    iprot.readStructBegin()
18948 
    while True:
18949 
      (fname, ftype, fid) = iprot.readFieldBegin()
18950 
      if ftype == TType.STOP:
18951 
        break
18952 
      if fid == 1:
18953 
        if ftype == TType.I64:
18954 
          self.orderId = iprot.readI64();
18955 
        else:
18956 
          iprot.skip(ftype)
18957 
      elif fid == 2:
18958 
        if ftype == TType.I32:
18959 
          self.delayReason = iprot.readI32();
18960 
        else:
18961 
          iprot.skip(ftype)
3986 chandransh 18962 
      elif fid == 3:
18963 
        if ftype == TType.I64:
18964 
          self.furtherDelay = iprot.readI64();
18965 
        else:
18966 
          iprot.skip(ftype)
4647 rajveer 18967 
      elif fid == 4:
18968 
        if ftype == TType.STRING:
18969 
          self.delayReasonText = iprot.readString();
18970 
        else:
18971 
          iprot.skip(ftype)
3553 chandransh 18972 
      else:
18973 
        iprot.skip(ftype)
18974 
      iprot.readFieldEnd()
18975 
    iprot.readStructEnd()
18976 
 
18977 
  def write(self, oprot):
18978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18980 
      return
18981 
    oprot.writeStructBegin('addDelayReason_args')
18982 
    if self.orderId is not None:
18983 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18984 
      oprot.writeI64(self.orderId)
18985 
      oprot.writeFieldEnd()
18986 
    if self.delayReason is not None:
18987 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18988 
      oprot.writeI32(self.delayReason)
18989 
      oprot.writeFieldEnd()
3986 chandransh 18990 
    if self.furtherDelay is not None:
18991 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18992 
      oprot.writeI64(self.furtherDelay)
18993 
      oprot.writeFieldEnd()
4647 rajveer 18994 
    if self.delayReasonText is not None:
18995 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18996 
      oprot.writeString(self.delayReasonText)
18997 
      oprot.writeFieldEnd()
3553 chandransh 18998 
    oprot.writeFieldStop()
18999 
    oprot.writeStructEnd()
19000 
 
19001 
  def validate(self):
19002 
    return
19003 
 
19004 
 
19005 
  def __repr__(self):
19006 
    L = ['%s=%r' % (key, value)
19007 
      for key, value in self.__dict__.iteritems()]
19008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19009 
 
19010 
  def __eq__(self, other):
19011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19012 
 
19013 
  def __ne__(self, other):
19014 
    return not (self == other)
19015 
 
19016 
class addDelayReason_result:
19017 
  """
19018 
  Attributes:
19019 
   - success
19020 
   - ex
19021 
  """
19022 
 
19023 
  thrift_spec = (
19024 
    (0, TType.BOOL, 'success', None, None, ), # 0
19025 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19026 
  )
19027 
 
19028 
  def __init__(self, success=None, ex=None,):
19029 
    self.success = success
19030 
    self.ex = ex
19031 
 
19032 
  def read(self, iprot):
19033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19035 
      return
19036 
    iprot.readStructBegin()
19037 
    while True:
19038 
      (fname, ftype, fid) = iprot.readFieldBegin()
19039 
      if ftype == TType.STOP:
19040 
        break
19041 
      if fid == 0:
19042 
        if ftype == TType.BOOL:
19043 
          self.success = iprot.readBool();
19044 
        else:
19045 
          iprot.skip(ftype)
19046 
      elif fid == 1:
19047 
        if ftype == TType.STRUCT:
19048 
          self.ex = TransactionServiceException()
19049 
          self.ex.read(iprot)
19050 
        else:
19051 
          iprot.skip(ftype)
19052 
      else:
19053 
        iprot.skip(ftype)
19054 
      iprot.readFieldEnd()
19055 
    iprot.readStructEnd()
19056 
 
19057 
  def write(self, oprot):
19058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19060 
      return
19061 
    oprot.writeStructBegin('addDelayReason_result')
19062 
    if self.success is not None:
19063 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19064 
      oprot.writeBool(self.success)
19065 
      oprot.writeFieldEnd()
19066 
    if self.ex is not None:
19067 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19068 
      self.ex.write(oprot)
19069 
      oprot.writeFieldEnd()
19070 
    oprot.writeFieldStop()
19071 
    oprot.writeStructEnd()
19072 
 
19073 
  def validate(self):
19074 
    return
19075 
 
19076 
 
19077 
  def __repr__(self):
19078 
    L = ['%s=%r' % (key, value)
19079 
      for key, value in self.__dict__.iteritems()]
19080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19081 
 
19082 
  def __eq__(self, other):
19083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19084 
 
19085 
  def __ne__(self, other):
19086 
    return not (self == other)
3956 chandransh 19087 
 
19088 
class reconcileCodCollection_args:
19089 
  """
19090 
  Attributes:
19091 
   - collectedAmountMap
19092 
   - xferBy
19093 
   - xferTxnId
19094 
   - xferDate
19095 
  """
19096 
 
19097 
  thrift_spec = (
19098 
    None, # 0
19099 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19100 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19101 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19102 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19103 
  )
19104 
 
19105 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19106 
    self.collectedAmountMap = collectedAmountMap
19107 
    self.xferBy = xferBy
19108 
    self.xferTxnId = xferTxnId
19109 
    self.xferDate = xferDate
19110 
 
19111 
  def read(self, iprot):
19112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19114 
      return
19115 
    iprot.readStructBegin()
19116 
    while True:
19117 
      (fname, ftype, fid) = iprot.readFieldBegin()
19118 
      if ftype == TType.STOP:
19119 
        break
19120 
      if fid == 1:
19121 
        if ftype == TType.MAP:
19122 
          self.collectedAmountMap = {}
6031 rajveer 19123 
          (_ktype411, _vtype412, _size410 ) = iprot.readMapBegin()
19124 
          for _i414 in xrange(_size410):
19125 
            _key415 = iprot.readString();
19126 
            _val416 = iprot.readDouble();
19127 
            self.collectedAmountMap[_key415] = _val416
3956 chandransh 19128 
          iprot.readMapEnd()
19129 
        else:
19130 
          iprot.skip(ftype)
19131 
      elif fid == 2:
19132 
        if ftype == TType.STRING:
19133 
          self.xferBy = iprot.readString();
19134 
        else:
19135 
          iprot.skip(ftype)
19136 
      elif fid == 3:
19137 
        if ftype == TType.STRING:
19138 
          self.xferTxnId = iprot.readString();
19139 
        else:
19140 
          iprot.skip(ftype)
19141 
      elif fid == 4:
19142 
        if ftype == TType.I64:
19143 
          self.xferDate = iprot.readI64();
19144 
        else:
19145 
          iprot.skip(ftype)
19146 
      else:
19147 
        iprot.skip(ftype)
19148 
      iprot.readFieldEnd()
19149 
    iprot.readStructEnd()
19150 
 
19151 
  def write(self, oprot):
19152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19154 
      return
19155 
    oprot.writeStructBegin('reconcileCodCollection_args')
19156 
    if self.collectedAmountMap is not None:
19157 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19158 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6031 rajveer 19159 
      for kiter417,viter418 in self.collectedAmountMap.items():
19160 
        oprot.writeString(kiter417)
19161 
        oprot.writeDouble(viter418)
3956 chandransh 19162 
      oprot.writeMapEnd()
19163 
      oprot.writeFieldEnd()
19164 
    if self.xferBy is not None:
19165 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19166 
      oprot.writeString(self.xferBy)
19167 
      oprot.writeFieldEnd()
19168 
    if self.xferTxnId is not None:
19169 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19170 
      oprot.writeString(self.xferTxnId)
19171 
      oprot.writeFieldEnd()
19172 
    if self.xferDate is not None:
19173 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19174 
      oprot.writeI64(self.xferDate)
19175 
      oprot.writeFieldEnd()
19176 
    oprot.writeFieldStop()
19177 
    oprot.writeStructEnd()
19178 
 
19179 
  def validate(self):
19180 
    return
19181 
 
19182 
 
19183 
  def __repr__(self):
19184 
    L = ['%s=%r' % (key, value)
19185 
      for key, value in self.__dict__.iteritems()]
19186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19187 
 
19188 
  def __eq__(self, other):
19189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19190 
 
19191 
  def __ne__(self, other):
19192 
    return not (self == other)
19193 
 
19194 
class reconcileCodCollection_result:
19195 
  """
19196 
  Attributes:
19197 
   - success
19198 
   - ex
19199 
  """
19200 
 
19201 
  thrift_spec = (
19202 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19204 
  )
19205 
 
19206 
  def __init__(self, success=None, ex=None,):
19207 
    self.success = success
19208 
    self.ex = ex
19209 
 
19210 
  def read(self, iprot):
19211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19213 
      return
19214 
    iprot.readStructBegin()
19215 
    while True:
19216 
      (fname, ftype, fid) = iprot.readFieldBegin()
19217 
      if ftype == TType.STOP:
19218 
        break
19219 
      if fid == 0:
19220 
        if ftype == TType.MAP:
19221 
          self.success = {}
6031 rajveer 19222 
          (_ktype420, _vtype421, _size419 ) = iprot.readMapBegin()
19223 
          for _i423 in xrange(_size419):
19224 
            _key424 = iprot.readString();
19225 
            _val425 = iprot.readString();
19226 
            self.success[_key424] = _val425
3956 chandransh 19227 
          iprot.readMapEnd()
19228 
        else:
19229 
          iprot.skip(ftype)
19230 
      elif fid == 1:
19231 
        if ftype == TType.STRUCT:
19232 
          self.ex = TransactionServiceException()
19233 
          self.ex.read(iprot)
19234 
        else:
19235 
          iprot.skip(ftype)
19236 
      else:
19237 
        iprot.skip(ftype)
19238 
      iprot.readFieldEnd()
19239 
    iprot.readStructEnd()
19240 
 
19241 
  def write(self, oprot):
19242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19244 
      return
19245 
    oprot.writeStructBegin('reconcileCodCollection_result')
19246 
    if self.success is not None:
19247 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19248 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6031 rajveer 19249 
      for kiter426,viter427 in self.success.items():
19250 
        oprot.writeString(kiter426)
19251 
        oprot.writeString(viter427)
3956 chandransh 19252 
      oprot.writeMapEnd()
19253 
      oprot.writeFieldEnd()
19254 
    if self.ex is not None:
19255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19256 
      self.ex.write(oprot)
19257 
      oprot.writeFieldEnd()
19258 
    oprot.writeFieldStop()
19259 
    oprot.writeStructEnd()
19260 
 
19261 
  def validate(self):
19262 
    return
19263 
 
19264 
 
19265 
  def __repr__(self):
19266 
    L = ['%s=%r' % (key, value)
19267 
      for key, value in self.__dict__.iteritems()]
19268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19269 
 
19270 
  def __eq__(self, other):
19271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19272 
 
19273 
  def __ne__(self, other):
19274 
    return not (self == other)
4008 mandeep.dh 19275 
 
19276 
class getTransactionsRequiringExtraProcessing_args:
19277 
  """
19278 
  Attributes:
19279 
   - category
19280 
  """
19281 
 
19282 
  thrift_spec = (
19283 
    None, # 0
19284 
    (1, TType.I32, 'category', None, None, ), # 1
19285 
  )
19286 
 
19287 
  def __init__(self, category=None,):
19288 
    self.category = category
19289 
 
19290 
  def read(self, iprot):
19291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19293 
      return
19294 
    iprot.readStructBegin()
19295 
    while True:
19296 
      (fname, ftype, fid) = iprot.readFieldBegin()
19297 
      if ftype == TType.STOP:
19298 
        break
19299 
      if fid == 1:
19300 
        if ftype == TType.I32:
19301 
          self.category = iprot.readI32();
19302 
        else:
19303 
          iprot.skip(ftype)
19304 
      else:
19305 
        iprot.skip(ftype)
19306 
      iprot.readFieldEnd()
19307 
    iprot.readStructEnd()
19308 
 
19309 
  def write(self, oprot):
19310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19312 
      return
19313 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19314 
    if self.category is not None:
19315 
      oprot.writeFieldBegin('category', TType.I32, 1)
19316 
      oprot.writeI32(self.category)
19317 
      oprot.writeFieldEnd()
19318 
    oprot.writeFieldStop()
19319 
    oprot.writeStructEnd()
19320 
 
19321 
  def validate(self):
19322 
    return
19323 
 
19324 
 
19325 
  def __repr__(self):
19326 
    L = ['%s=%r' % (key, value)
19327 
      for key, value in self.__dict__.iteritems()]
19328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19329 
 
19330 
  def __eq__(self, other):
19331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19332 
 
19333 
  def __ne__(self, other):
19334 
    return not (self == other)
19335 
 
19336 
class getTransactionsRequiringExtraProcessing_result:
19337 
  """
19338 
  Attributes:
19339 
   - success
19340 
  """
19341 
 
19342 
  thrift_spec = (
19343 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19344 
  )
19345 
 
19346 
  def __init__(self, success=None,):
19347 
    self.success = success
19348 
 
19349 
  def read(self, iprot):
19350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19352 
      return
19353 
    iprot.readStructBegin()
19354 
    while True:
19355 
      (fname, ftype, fid) = iprot.readFieldBegin()
19356 
      if ftype == TType.STOP:
19357 
        break
19358 
      if fid == 0:
19359 
        if ftype == TType.LIST:
19360 
          self.success = []
6031 rajveer 19361 
          (_etype431, _size428) = iprot.readListBegin()
19362 
          for _i432 in xrange(_size428):
19363 
            _elem433 = iprot.readI64();
19364 
            self.success.append(_elem433)
4008 mandeep.dh 19365 
          iprot.readListEnd()
19366 
        else:
19367 
          iprot.skip(ftype)
19368 
      else:
19369 
        iprot.skip(ftype)
19370 
      iprot.readFieldEnd()
19371 
    iprot.readStructEnd()
19372 
 
19373 
  def write(self, oprot):
19374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19376 
      return
19377 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19378 
    if self.success is not None:
19379 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19380 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 19381 
      for iter434 in self.success:
19382 
        oprot.writeI64(iter434)
4008 mandeep.dh 19383 
      oprot.writeListEnd()
19384 
      oprot.writeFieldEnd()
19385 
    oprot.writeFieldStop()
19386 
    oprot.writeStructEnd()
19387 
 
19388 
  def validate(self):
19389 
    return
19390 
 
19391 
 
19392 
  def __repr__(self):
19393 
    L = ['%s=%r' % (key, value)
19394 
      for key, value in self.__dict__.iteritems()]
19395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19396 
 
19397 
  def __eq__(self, other):
19398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19399 
 
19400 
  def __ne__(self, other):
19401 
    return not (self == other)
19402 
 
19403 
class markTransactionAsProcessed_args:
19404 
  """
19405 
  Attributes:
19406 
   - transactionId
19407 
   - category
19408 
  """
19409 
 
19410 
  thrift_spec = (
19411 
    None, # 0
19412 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19413 
    (2, TType.I32, 'category', None, None, ), # 2
19414 
  )
19415 
 
19416 
  def __init__(self, transactionId=None, category=None,):
19417 
    self.transactionId = transactionId
19418 
    self.category = category
19419 
 
19420 
  def read(self, iprot):
19421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19423 
      return
19424 
    iprot.readStructBegin()
19425 
    while True:
19426 
      (fname, ftype, fid) = iprot.readFieldBegin()
19427 
      if ftype == TType.STOP:
19428 
        break
19429 
      if fid == 1:
19430 
        if ftype == TType.I64:
19431 
          self.transactionId = iprot.readI64();
19432 
        else:
19433 
          iprot.skip(ftype)
19434 
      elif fid == 2:
19435 
        if ftype == TType.I32:
19436 
          self.category = iprot.readI32();
19437 
        else:
19438 
          iprot.skip(ftype)
19439 
      else:
19440 
        iprot.skip(ftype)
19441 
      iprot.readFieldEnd()
19442 
    iprot.readStructEnd()
19443 
 
19444 
  def write(self, oprot):
19445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19447 
      return
19448 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19449 
    if self.transactionId is not None:
19450 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19451 
      oprot.writeI64(self.transactionId)
19452 
      oprot.writeFieldEnd()
19453 
    if self.category is not None:
19454 
      oprot.writeFieldBegin('category', TType.I32, 2)
19455 
      oprot.writeI32(self.category)
19456 
      oprot.writeFieldEnd()
19457 
    oprot.writeFieldStop()
19458 
    oprot.writeStructEnd()
19459 
 
19460 
  def validate(self):
19461 
    return
19462 
 
19463 
 
19464 
  def __repr__(self):
19465 
    L = ['%s=%r' % (key, value)
19466 
      for key, value in self.__dict__.iteritems()]
19467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19468 
 
19469 
  def __eq__(self, other):
19470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19471 
 
19472 
  def __ne__(self, other):
19473 
    return not (self == other)
19474 
 
19475 
class markTransactionAsProcessed_result:
19476 
 
19477 
  thrift_spec = (
19478 
  )
19479 
 
19480 
  def read(self, iprot):
19481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19483 
      return
19484 
    iprot.readStructBegin()
19485 
    while True:
19486 
      (fname, ftype, fid) = iprot.readFieldBegin()
19487 
      if ftype == TType.STOP:
19488 
        break
19489 
      else:
19490 
        iprot.skip(ftype)
19491 
      iprot.readFieldEnd()
19492 
    iprot.readStructEnd()
19493 
 
19494 
  def write(self, oprot):
19495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19497 
      return
19498 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19499 
    oprot.writeFieldStop()
19500 
    oprot.writeStructEnd()
19501 
 
19502 
  def validate(self):
19503 
    return
19504 
 
19505 
 
19506 
  def __repr__(self):
19507 
    L = ['%s=%r' % (key, value)
19508 
      for key, value in self.__dict__.iteritems()]
19509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19510 
 
19511 
  def __eq__(self, other):
19512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19513 
 
19514 
  def __ne__(self, other):
19515 
    return not (self == other)
4018 chandransh 19516 
 
19517 
class getItemWiseRiskyOrdersCount_args:
19518 
 
19519 
  thrift_spec = (
19520 
  )
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 
      else:
19532 
        iprot.skip(ftype)
19533 
      iprot.readFieldEnd()
19534 
    iprot.readStructEnd()
19535 
 
19536 
  def write(self, oprot):
19537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19539 
      return
19540 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19541 
    oprot.writeFieldStop()
19542 
    oprot.writeStructEnd()
19543 
 
19544 
  def validate(self):
19545 
    return
19546 
 
19547 
 
19548 
  def __repr__(self):
19549 
    L = ['%s=%r' % (key, value)
19550 
      for key, value in self.__dict__.iteritems()]
19551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19552 
 
19553 
  def __eq__(self, other):
19554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19555 
 
19556 
  def __ne__(self, other):
19557 
    return not (self == other)
19558 
 
19559 
class getItemWiseRiskyOrdersCount_result:
19560 
  """
19561 
  Attributes:
19562 
   - success
19563 
  """
19564 
 
19565 
  thrift_spec = (
19566 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19567 
  )
19568 
 
19569 
  def __init__(self, success=None,):
19570 
    self.success = success
19571 
 
19572 
  def read(self, iprot):
19573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19575 
      return
19576 
    iprot.readStructBegin()
19577 
    while True:
19578 
      (fname, ftype, fid) = iprot.readFieldBegin()
19579 
      if ftype == TType.STOP:
19580 
        break
19581 
      if fid == 0:
19582 
        if ftype == TType.MAP:
19583 
          self.success = {}
6031 rajveer 19584 
          (_ktype436, _vtype437, _size435 ) = iprot.readMapBegin()
19585 
          for _i439 in xrange(_size435):
19586 
            _key440 = iprot.readI64();
19587 
            _val441 = iprot.readI64();
19588 
            self.success[_key440] = _val441
4018 chandransh 19589 
          iprot.readMapEnd()
19590 
        else:
19591 
          iprot.skip(ftype)
19592 
      else:
19593 
        iprot.skip(ftype)
19594 
      iprot.readFieldEnd()
19595 
    iprot.readStructEnd()
19596 
 
19597 
  def write(self, oprot):
19598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19600 
      return
19601 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19602 
    if self.success is not None:
19603 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19604 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 19605 
      for kiter442,viter443 in self.success.items():
19606 
        oprot.writeI64(kiter442)
19607 
        oprot.writeI64(viter443)
4018 chandransh 19608 
      oprot.writeMapEnd()
19609 
      oprot.writeFieldEnd()
19610 
    oprot.writeFieldStop()
19611 
    oprot.writeStructEnd()
19612 
 
19613 
  def validate(self):
19614 
    return
19615 
 
19616 
 
19617 
  def __repr__(self):
19618 
    L = ['%s=%r' % (key, value)
19619 
      for key, value in self.__dict__.iteritems()]
19620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19621 
 
19622 
  def __eq__(self, other):
19623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19624 
 
19625 
  def __ne__(self, other):
19626 
    return not (self == other)
4247 rajveer 19627 
 
4295 varun.gupt 19628 
class getOrdersForItemIds_args:
19629 
  """
19630 
  Attributes:
19631 
   - itemIds
19632 
  """
19633 
 
19634 
  thrift_spec = (
19635 
    None, # 0
19636 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19637 
  )
19638 
 
19639 
  def __init__(self, itemIds=None,):
19640 
    self.itemIds = itemIds
19641 
 
19642 
  def read(self, iprot):
19643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19645 
      return
19646 
    iprot.readStructBegin()
19647 
    while True:
19648 
      (fname, ftype, fid) = iprot.readFieldBegin()
19649 
      if ftype == TType.STOP:
19650 
        break
19651 
      if fid == 1:
19652 
        if ftype == TType.LIST:
19653 
          self.itemIds = []
6031 rajveer 19654 
          (_etype447, _size444) = iprot.readListBegin()
19655 
          for _i448 in xrange(_size444):
19656 
            _elem449 = iprot.readI64();
19657 
            self.itemIds.append(_elem449)
4295 varun.gupt 19658 
          iprot.readListEnd()
19659 
        else:
19660 
          iprot.skip(ftype)
19661 
      else:
19662 
        iprot.skip(ftype)
19663 
      iprot.readFieldEnd()
19664 
    iprot.readStructEnd()
19665 
 
19666 
  def write(self, oprot):
19667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19669 
      return
19670 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19671 
    if self.itemIds is not None:
19672 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19673 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6031 rajveer 19674 
      for iter450 in self.itemIds:
19675 
        oprot.writeI64(iter450)
4295 varun.gupt 19676 
      oprot.writeListEnd()
19677 
      oprot.writeFieldEnd()
19678 
    oprot.writeFieldStop()
19679 
    oprot.writeStructEnd()
19680 
 
19681 
  def validate(self):
19682 
    return
19683 
 
19684 
 
19685 
  def __repr__(self):
19686 
    L = ['%s=%r' % (key, value)
19687 
      for key, value in self.__dict__.iteritems()]
19688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19689 
 
19690 
  def __eq__(self, other):
19691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19692 
 
19693 
  def __ne__(self, other):
19694 
    return not (self == other)
19695 
 
19696 
class getOrdersForItemIds_result:
19697 
  """
19698 
  Attributes:
19699 
   - success
19700 
  """
19701 
 
19702 
  thrift_spec = (
19703 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19704 
  )
19705 
 
19706 
  def __init__(self, success=None,):
19707 
    self.success = success
19708 
 
19709 
  def read(self, iprot):
19710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19712 
      return
19713 
    iprot.readStructBegin()
19714 
    while True:
19715 
      (fname, ftype, fid) = iprot.readFieldBegin()
19716 
      if ftype == TType.STOP:
19717 
        break
19718 
      if fid == 0:
19719 
        if ftype == TType.LIST:
19720 
          self.success = []
6031 rajveer 19721 
          (_etype454, _size451) = iprot.readListBegin()
19722 
          for _i455 in xrange(_size451):
19723 
            _elem456 = Order()
19724 
            _elem456.read(iprot)
19725 
            self.success.append(_elem456)
4295 varun.gupt 19726 
          iprot.readListEnd()
19727 
        else:
19728 
          iprot.skip(ftype)
19729 
      else:
19730 
        iprot.skip(ftype)
19731 
      iprot.readFieldEnd()
19732 
    iprot.readStructEnd()
19733 
 
19734 
  def write(self, oprot):
19735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19737 
      return
19738 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19739 
    if self.success is not None:
19740 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19741 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 19742 
      for iter457 in self.success:
19743 
        iter457.write(oprot)
4295 varun.gupt 19744 
      oprot.writeListEnd()
19745 
      oprot.writeFieldEnd()
19746 
    oprot.writeFieldStop()
19747 
    oprot.writeStructEnd()
19748 
 
19749 
  def validate(self):
19750 
    return
19751 
 
19752 
 
19753 
  def __repr__(self):
19754 
    L = ['%s=%r' % (key, value)
19755 
      for key, value in self.__dict__.iteritems()]
19756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19757 
 
19758 
  def __eq__(self, other):
19759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19760 
 
19761 
  def __ne__(self, other):
19762 
    return not (self == other)
19763 
 
4247 rajveer 19764 
class markOrderCancellationRequestReceived_args:
19765 
  """
19766 
  Attributes:
19767 
   - orderId
19768 
  """
19769 
 
19770 
  thrift_spec = (
19771 
    None, # 0
19772 
    (1, TType.I64, 'orderId', None, None, ), # 1
19773 
  )
19774 
 
19775 
  def __init__(self, orderId=None,):
19776 
    self.orderId = orderId
19777 
 
19778 
  def read(self, iprot):
19779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19781 
      return
19782 
    iprot.readStructBegin()
19783 
    while True:
19784 
      (fname, ftype, fid) = iprot.readFieldBegin()
19785 
      if ftype == TType.STOP:
19786 
        break
19787 
      if fid == 1:
19788 
        if ftype == TType.I64:
19789 
          self.orderId = iprot.readI64();
19790 
        else:
19791 
          iprot.skip(ftype)
19792 
      else:
19793 
        iprot.skip(ftype)
19794 
      iprot.readFieldEnd()
19795 
    iprot.readStructEnd()
19796 
 
19797 
  def write(self, oprot):
19798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19800 
      return
19801 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19802 
    if self.orderId is not None:
19803 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19804 
      oprot.writeI64(self.orderId)
19805 
      oprot.writeFieldEnd()
19806 
    oprot.writeFieldStop()
19807 
    oprot.writeStructEnd()
19808 
 
19809 
  def validate(self):
19810 
    return
19811 
 
19812 
 
19813 
  def __repr__(self):
19814 
    L = ['%s=%r' % (key, value)
19815 
      for key, value in self.__dict__.iteritems()]
19816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19817 
 
19818 
  def __eq__(self, other):
19819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19820 
 
19821 
  def __ne__(self, other):
19822 
    return not (self == other)
19823 
 
19824 
class markOrderCancellationRequestReceived_result:
19825 
  """
19826 
  Attributes:
19827 
   - ex
19828 
  """
19829 
 
19830 
  thrift_spec = (
19831 
    None, # 0
19832 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19833 
  )
19834 
 
19835 
  def __init__(self, ex=None,):
19836 
    self.ex = ex
19837 
 
19838 
  def read(self, iprot):
19839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19841 
      return
19842 
    iprot.readStructBegin()
19843 
    while True:
19844 
      (fname, ftype, fid) = iprot.readFieldBegin()
19845 
      if ftype == TType.STOP:
19846 
        break
19847 
      if fid == 1:
19848 
        if ftype == TType.STRUCT:
19849 
          self.ex = TransactionServiceException()
19850 
          self.ex.read(iprot)
19851 
        else:
19852 
          iprot.skip(ftype)
19853 
      else:
19854 
        iprot.skip(ftype)
19855 
      iprot.readFieldEnd()
19856 
    iprot.readStructEnd()
19857 
 
19858 
  def write(self, oprot):
19859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19861 
      return
19862 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
19863 
    if self.ex is not None:
19864 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19865 
      self.ex.write(oprot)
19866 
      oprot.writeFieldEnd()
19867 
    oprot.writeFieldStop()
19868 
    oprot.writeStructEnd()
19869 
 
19870 
  def validate(self):
19871 
    return
19872 
 
19873 
 
19874 
  def __repr__(self):
19875 
    L = ['%s=%r' % (key, value)
19876 
      for key, value in self.__dict__.iteritems()]
19877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19878 
 
19879 
  def __eq__(self, other):
19880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19881 
 
19882 
  def __ne__(self, other):
19883 
    return not (self == other)
19884 
 
19885 
class markOrderCancellationRequestConfirmed_args:
19886 
  """
19887 
  Attributes:
19888 
   - orderId
19889 
  """
19890 
 
19891 
  thrift_spec = (
19892 
    None, # 0
19893 
    (1, TType.I64, 'orderId', None, None, ), # 1
19894 
  )
19895 
 
19896 
  def __init__(self, orderId=None,):
19897 
    self.orderId = orderId
19898 
 
19899 
  def read(self, iprot):
19900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19902 
      return
19903 
    iprot.readStructBegin()
19904 
    while True:
19905 
      (fname, ftype, fid) = iprot.readFieldBegin()
19906 
      if ftype == TType.STOP:
19907 
        break
19908 
      if fid == 1:
19909 
        if ftype == TType.I64:
19910 
          self.orderId = iprot.readI64();
19911 
        else:
19912 
          iprot.skip(ftype)
19913 
      else:
19914 
        iprot.skip(ftype)
19915 
      iprot.readFieldEnd()
19916 
    iprot.readStructEnd()
19917 
 
19918 
  def write(self, oprot):
19919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19921 
      return
19922 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
19923 
    if self.orderId is not None:
19924 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19925 
      oprot.writeI64(self.orderId)
19926 
      oprot.writeFieldEnd()
19927 
    oprot.writeFieldStop()
19928 
    oprot.writeStructEnd()
19929 
 
19930 
  def validate(self):
19931 
    return
19932 
 
19933 
 
19934 
  def __repr__(self):
19935 
    L = ['%s=%r' % (key, value)
19936 
      for key, value in self.__dict__.iteritems()]
19937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19938 
 
19939 
  def __eq__(self, other):
19940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19941 
 
19942 
  def __ne__(self, other):
19943 
    return not (self == other)
19944 
 
19945 
class markOrderCancellationRequestConfirmed_result:
19946 
  """
19947 
  Attributes:
19948 
   - ex
19949 
  """
19950 
 
19951 
  thrift_spec = (
19952 
    None, # 0
19953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19954 
  )
19955 
 
19956 
  def __init__(self, ex=None,):
19957 
    self.ex = ex
19958 
 
19959 
  def read(self, iprot):
19960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19962 
      return
19963 
    iprot.readStructBegin()
19964 
    while True:
19965 
      (fname, ftype, fid) = iprot.readFieldBegin()
19966 
      if ftype == TType.STOP:
19967 
        break
19968 
      if fid == 1:
19969 
        if ftype == TType.STRUCT:
19970 
          self.ex = TransactionServiceException()
19971 
          self.ex.read(iprot)
19972 
        else:
19973 
          iprot.skip(ftype)
19974 
      else:
19975 
        iprot.skip(ftype)
19976 
      iprot.readFieldEnd()
19977 
    iprot.readStructEnd()
19978 
 
19979 
  def write(self, oprot):
19980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19982 
      return
19983 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19984 
    if self.ex is not None:
19985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19986 
      self.ex.write(oprot)
19987 
      oprot.writeFieldEnd()
19988 
    oprot.writeFieldStop()
19989 
    oprot.writeStructEnd()
19990 
 
19991 
  def validate(self):
19992 
    return
19993 
 
19994 
 
19995 
  def __repr__(self):
19996 
    L = ['%s=%r' % (key, value)
19997 
      for key, value in self.__dict__.iteritems()]
19998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19999 
 
20000 
  def __eq__(self, other):
20001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20002 
 
20003 
  def __ne__(self, other):
20004 
    return not (self == other)
20005 
 
20006 
class markOrderCancellationRequestDenied_args:
20007 
  """
20008 
  Attributes:
20009 
   - orderId
20010 
  """
20011 
 
20012 
  thrift_spec = (
20013 
    None, # 0
20014 
    (1, TType.I64, 'orderId', None, None, ), # 1
20015 
  )
20016 
 
20017 
  def __init__(self, orderId=None,):
20018 
    self.orderId = orderId
20019 
 
20020 
  def read(self, iprot):
20021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20023 
      return
20024 
    iprot.readStructBegin()
20025 
    while True:
20026 
      (fname, ftype, fid) = iprot.readFieldBegin()
20027 
      if ftype == TType.STOP:
20028 
        break
20029 
      if fid == 1:
20030 
        if ftype == TType.I64:
20031 
          self.orderId = iprot.readI64();
20032 
        else:
20033 
          iprot.skip(ftype)
20034 
      else:
20035 
        iprot.skip(ftype)
20036 
      iprot.readFieldEnd()
20037 
    iprot.readStructEnd()
20038 
 
20039 
  def write(self, oprot):
20040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20042 
      return
20043 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20044 
    if self.orderId is not None:
20045 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20046 
      oprot.writeI64(self.orderId)
20047 
      oprot.writeFieldEnd()
20048 
    oprot.writeFieldStop()
20049 
    oprot.writeStructEnd()
20050 
 
20051 
  def validate(self):
20052 
    return
20053 
 
20054 
 
20055 
  def __repr__(self):
20056 
    L = ['%s=%r' % (key, value)
20057 
      for key, value in self.__dict__.iteritems()]
20058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20059 
 
20060 
  def __eq__(self, other):
20061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20062 
 
20063 
  def __ne__(self, other):
20064 
    return not (self == other)
20065 
 
20066 
class markOrderCancellationRequestDenied_result:
20067 
  """
20068 
  Attributes:
20069 
   - ex
20070 
  """
20071 
 
20072 
  thrift_spec = (
20073 
    None, # 0
20074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20075 
  )
20076 
 
20077 
  def __init__(self, ex=None,):
20078 
    self.ex = ex
20079 
 
20080 
  def read(self, iprot):
20081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20083 
      return
20084 
    iprot.readStructBegin()
20085 
    while True:
20086 
      (fname, ftype, fid) = iprot.readFieldBegin()
20087 
      if ftype == TType.STOP:
20088 
        break
20089 
      if fid == 1:
20090 
        if ftype == TType.STRUCT:
20091 
          self.ex = TransactionServiceException()
20092 
          self.ex.read(iprot)
20093 
        else:
20094 
          iprot.skip(ftype)
20095 
      else:
20096 
        iprot.skip(ftype)
20097 
      iprot.readFieldEnd()
20098 
    iprot.readStructEnd()
20099 
 
20100 
  def write(self, oprot):
20101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20103 
      return
20104 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20105 
    if self.ex is not None:
20106 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20107 
      self.ex.write(oprot)
20108 
      oprot.writeFieldEnd()
20109 
    oprot.writeFieldStop()
20110 
    oprot.writeStructEnd()
20111 
 
20112 
  def validate(self):
20113 
    return
20114 
 
20115 
 
20116 
  def __repr__(self):
20117 
    L = ['%s=%r' % (key, value)
20118 
      for key, value in self.__dict__.iteritems()]
20119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20120 
 
20121 
  def __eq__(self, other):
20122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20123 
 
20124 
  def __ne__(self, other):
20125 
    return not (self == other)
20126 
 
4258 rajveer 20127 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20128 
  """
20129 
  Attributes:
4258 rajveer 20130 
   - transactionId
4247 rajveer 20131 
  """
20132 
 
20133 
  thrift_spec = (
20134 
    None, # 0
4258 rajveer 20135 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20136 
  )
20137 
 
4258 rajveer 20138 
  def __init__(self, transactionId=None,):
20139 
    self.transactionId = transactionId
4247 rajveer 20140 
 
20141 
  def read(self, iprot):
20142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20144 
      return
20145 
    iprot.readStructBegin()
20146 
    while True:
20147 
      (fname, ftype, fid) = iprot.readFieldBegin()
20148 
      if ftype == TType.STOP:
20149 
        break
20150 
      if fid == 1:
20151 
        if ftype == TType.I64:
4258 rajveer 20152 
          self.transactionId = iprot.readI64();
4247 rajveer 20153 
        else:
20154 
          iprot.skip(ftype)
20155 
      else:
20156 
        iprot.skip(ftype)
20157 
      iprot.readFieldEnd()
20158 
    iprot.readStructEnd()
20159 
 
20160 
  def write(self, oprot):
20161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20163 
      return
4258 rajveer 20164 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20165 
    if self.transactionId is not None:
20166 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20167 
      oprot.writeI64(self.transactionId)
4247 rajveer 20168 
      oprot.writeFieldEnd()
20169 
    oprot.writeFieldStop()
20170 
    oprot.writeStructEnd()
20171 
 
20172 
  def validate(self):
20173 
    return
20174 
 
20175 
 
20176 
  def __repr__(self):
20177 
    L = ['%s=%r' % (key, value)
20178 
      for key, value in self.__dict__.iteritems()]
20179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20180 
 
20181 
  def __eq__(self, other):
20182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20183 
 
20184 
  def __ne__(self, other):
20185 
    return not (self == other)
20186 
 
4258 rajveer 20187 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20188 
  """
20189 
  Attributes:
20190 
   - ex
20191 
  """
20192 
 
20193 
  thrift_spec = (
20194 
    None, # 0
20195 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20196 
  )
20197 
 
20198 
  def __init__(self, ex=None,):
20199 
    self.ex = ex
20200 
 
20201 
  def read(self, iprot):
20202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20204 
      return
20205 
    iprot.readStructBegin()
20206 
    while True:
20207 
      (fname, ftype, fid) = iprot.readFieldBegin()
20208 
      if ftype == TType.STOP:
20209 
        break
20210 
      if fid == 1:
20211 
        if ftype == TType.STRUCT:
20212 
          self.ex = TransactionServiceException()
20213 
          self.ex.read(iprot)
20214 
        else:
20215 
          iprot.skip(ftype)
20216 
      else:
20217 
        iprot.skip(ftype)
20218 
      iprot.readFieldEnd()
20219 
    iprot.readStructEnd()
20220 
 
20221 
  def write(self, oprot):
20222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20224 
      return
4258 rajveer 20225 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20226 
    if self.ex is not None:
20227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20228 
      self.ex.write(oprot)
20229 
      oprot.writeFieldEnd()
20230 
    oprot.writeFieldStop()
20231 
    oprot.writeStructEnd()
20232 
 
20233 
  def validate(self):
20234 
    return
20235 
 
20236 
 
20237 
  def __repr__(self):
20238 
    L = ['%s=%r' % (key, value)
20239 
      for key, value in self.__dict__.iteritems()]
20240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20241 
 
20242 
  def __eq__(self, other):
20243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20244 
 
20245 
  def __ne__(self, other):
20246 
    return not (self == other)
4259 anupam.sin 20247 
 
20248 
class refundTransaction_args:
20249 
  """
20250 
  Attributes:
20251 
   - transactionId
20252 
   - refundedBy
20253 
   - reason
20254 
  """
20255 
 
20256 
  thrift_spec = (
20257 
    None, # 0
20258 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20259 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20260 
    (3, TType.STRING, 'reason', None, None, ), # 3
20261 
  )
20262 
 
20263 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20264 
    self.transactionId = transactionId
20265 
    self.refundedBy = refundedBy
20266 
    self.reason = reason
20267 
 
20268 
  def read(self, iprot):
20269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20271 
      return
20272 
    iprot.readStructBegin()
20273 
    while True:
20274 
      (fname, ftype, fid) = iprot.readFieldBegin()
20275 
      if ftype == TType.STOP:
20276 
        break
20277 
      if fid == 1:
20278 
        if ftype == TType.I64:
20279 
          self.transactionId = iprot.readI64();
20280 
        else:
20281 
          iprot.skip(ftype)
20282 
      elif fid == 2:
20283 
        if ftype == TType.STRING:
20284 
          self.refundedBy = iprot.readString();
20285 
        else:
20286 
          iprot.skip(ftype)
20287 
      elif fid == 3:
20288 
        if ftype == TType.STRING:
20289 
          self.reason = iprot.readString();
20290 
        else:
20291 
          iprot.skip(ftype)
20292 
      else:
20293 
        iprot.skip(ftype)
20294 
      iprot.readFieldEnd()
20295 
    iprot.readStructEnd()
20296 
 
20297 
  def write(self, oprot):
20298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20300 
      return
20301 
    oprot.writeStructBegin('refundTransaction_args')
20302 
    if self.transactionId is not None:
20303 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20304 
      oprot.writeI64(self.transactionId)
20305 
      oprot.writeFieldEnd()
20306 
    if self.refundedBy is not None:
20307 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20308 
      oprot.writeString(self.refundedBy)
20309 
      oprot.writeFieldEnd()
20310 
    if self.reason is not None:
20311 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20312 
      oprot.writeString(self.reason)
20313 
      oprot.writeFieldEnd()
20314 
    oprot.writeFieldStop()
20315 
    oprot.writeStructEnd()
20316 
 
20317 
  def validate(self):
20318 
    return
20319 
 
20320 
 
20321 
  def __repr__(self):
20322 
    L = ['%s=%r' % (key, value)
20323 
      for key, value in self.__dict__.iteritems()]
20324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20325 
 
20326 
  def __eq__(self, other):
20327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20328 
 
20329 
  def __ne__(self, other):
20330 
    return not (self == other)
20331 
 
20332 
class refundTransaction_result:
20333 
  """
20334 
  Attributes:
20335 
   - ex
20336 
  """
20337 
 
20338 
  thrift_spec = (
20339 
    None, # 0
20340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20341 
  )
20342 
 
20343 
  def __init__(self, ex=None,):
20344 
    self.ex = ex
20345 
 
20346 
  def read(self, iprot):
20347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20349 
      return
20350 
    iprot.readStructBegin()
20351 
    while True:
20352 
      (fname, ftype, fid) = iprot.readFieldBegin()
20353 
      if ftype == TType.STOP:
20354 
        break
20355 
      if fid == 1:
20356 
        if ftype == TType.STRUCT:
20357 
          self.ex = TransactionServiceException()
20358 
          self.ex.read(iprot)
20359 
        else:
20360 
          iprot.skip(ftype)
20361 
      else:
20362 
        iprot.skip(ftype)
20363 
      iprot.readFieldEnd()
20364 
    iprot.readStructEnd()
20365 
 
20366 
  def write(self, oprot):
20367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20369 
      return
20370 
    oprot.writeStructBegin('refundTransaction_result')
20371 
    if self.ex is not None:
20372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20373 
      self.ex.write(oprot)
20374 
      oprot.writeFieldEnd()
20375 
    oprot.writeFieldStop()
20376 
    oprot.writeStructEnd()
20377 
 
20378 
  def validate(self):
20379 
    return
20380 
 
20381 
 
20382 
  def __repr__(self):
20383 
    L = ['%s=%r' % (key, value)
20384 
      for key, value in self.__dict__.iteritems()]
20385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20386 
 
20387 
  def __eq__(self, other):
20388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20389 
 
20390 
  def __ne__(self, other):
20391 
    return not (self == other)
4285 rajveer 20392 
 
4324 mandeep.dh 20393 
class updateShipmentAddress_args:
20394 
  """
20395 
  Attributes:
20396 
   - orderId
20397 
   - addressId
20398 
  """
20399 
 
20400 
  thrift_spec = (
20401 
    None, # 0
20402 
    (1, TType.I64, 'orderId', None, None, ), # 1
20403 
    (2, TType.I64, 'addressId', None, None, ), # 2
20404 
  )
20405 
 
20406 
  def __init__(self, orderId=None, addressId=None,):
20407 
    self.orderId = orderId
20408 
    self.addressId = addressId
20409 
 
20410 
  def read(self, iprot):
20411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20413 
      return
20414 
    iprot.readStructBegin()
20415 
    while True:
20416 
      (fname, ftype, fid) = iprot.readFieldBegin()
20417 
      if ftype == TType.STOP:
20418 
        break
20419 
      if fid == 1:
20420 
        if ftype == TType.I64:
20421 
          self.orderId = iprot.readI64();
20422 
        else:
20423 
          iprot.skip(ftype)
20424 
      elif fid == 2:
20425 
        if ftype == TType.I64:
20426 
          self.addressId = iprot.readI64();
20427 
        else:
20428 
          iprot.skip(ftype)
20429 
      else:
20430 
        iprot.skip(ftype)
20431 
      iprot.readFieldEnd()
20432 
    iprot.readStructEnd()
20433 
 
20434 
  def write(self, oprot):
20435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20437 
      return
20438 
    oprot.writeStructBegin('updateShipmentAddress_args')
20439 
    if self.orderId is not None:
20440 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20441 
      oprot.writeI64(self.orderId)
20442 
      oprot.writeFieldEnd()
20443 
    if self.addressId is not None:
20444 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20445 
      oprot.writeI64(self.addressId)
20446 
      oprot.writeFieldEnd()
20447 
    oprot.writeFieldStop()
20448 
    oprot.writeStructEnd()
20449 
 
20450 
  def validate(self):
20451 
    return
20452 
 
20453 
 
20454 
  def __repr__(self):
20455 
    L = ['%s=%r' % (key, value)
20456 
      for key, value in self.__dict__.iteritems()]
20457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20458 
 
20459 
  def __eq__(self, other):
20460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20461 
 
20462 
  def __ne__(self, other):
20463 
    return not (self == other)
20464 
 
20465 
class updateShipmentAddress_result:
20466 
  """
20467 
  Attributes:
20468 
   - ex
20469 
  """
20470 
 
20471 
  thrift_spec = (
20472 
    None, # 0
20473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20474 
  )
20475 
 
20476 
  def __init__(self, ex=None,):
20477 
    self.ex = ex
20478 
 
20479 
  def read(self, iprot):
20480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20482 
      return
20483 
    iprot.readStructBegin()
20484 
    while True:
20485 
      (fname, ftype, fid) = iprot.readFieldBegin()
20486 
      if ftype == TType.STOP:
20487 
        break
20488 
      if fid == 1:
20489 
        if ftype == TType.STRUCT:
20490 
          self.ex = TransactionServiceException()
20491 
          self.ex.read(iprot)
20492 
        else:
20493 
          iprot.skip(ftype)
20494 
      else:
20495 
        iprot.skip(ftype)
20496 
      iprot.readFieldEnd()
20497 
    iprot.readStructEnd()
20498 
 
20499 
  def write(self, oprot):
20500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20502 
      return
20503 
    oprot.writeStructBegin('updateShipmentAddress_result')
20504 
    if self.ex is not None:
20505 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20506 
      self.ex.write(oprot)
20507 
      oprot.writeFieldEnd()
20508 
    oprot.writeFieldStop()
20509 
    oprot.writeStructEnd()
20510 
 
20511 
  def validate(self):
20512 
    return
20513 
 
20514 
 
20515 
  def __repr__(self):
20516 
    L = ['%s=%r' % (key, value)
20517 
      for key, value in self.__dict__.iteritems()]
20518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20519 
 
20520 
  def __eq__(self, other):
20521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20522 
 
20523 
  def __ne__(self, other):
20524 
    return not (self == other)
20525 
 
4285 rajveer 20526 
class acceptOrdersForItemId_args:
20527 
  """
20528 
  Attributes:
20529 
   - itemId
20530 
   - inventory
20531 
  """
20532 
 
20533 
  thrift_spec = (
20534 
    None, # 0
20535 
    (1, TType.I64, 'itemId', None, None, ), # 1
20536 
    (2, TType.I64, 'inventory', None, None, ), # 2
20537 
  )
20538 
 
20539 
  def __init__(self, itemId=None, inventory=None,):
20540 
    self.itemId = itemId
20541 
    self.inventory = inventory
20542 
 
20543 
  def read(self, iprot):
20544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20546 
      return
20547 
    iprot.readStructBegin()
20548 
    while True:
20549 
      (fname, ftype, fid) = iprot.readFieldBegin()
20550 
      if ftype == TType.STOP:
20551 
        break
20552 
      if fid == 1:
20553 
        if ftype == TType.I64:
20554 
          self.itemId = iprot.readI64();
20555 
        else:
20556 
          iprot.skip(ftype)
20557 
      elif fid == 2:
20558 
        if ftype == TType.I64:
20559 
          self.inventory = iprot.readI64();
20560 
        else:
20561 
          iprot.skip(ftype)
20562 
      else:
20563 
        iprot.skip(ftype)
20564 
      iprot.readFieldEnd()
20565 
    iprot.readStructEnd()
20566 
 
20567 
  def write(self, oprot):
20568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20570 
      return
20571 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20572 
    if self.itemId is not None:
20573 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20574 
      oprot.writeI64(self.itemId)
20575 
      oprot.writeFieldEnd()
20576 
    if self.inventory is not None:
20577 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20578 
      oprot.writeI64(self.inventory)
20579 
      oprot.writeFieldEnd()
20580 
    oprot.writeFieldStop()
20581 
    oprot.writeStructEnd()
20582 
 
20583 
  def validate(self):
20584 
    return
20585 
 
20586 
 
20587 
  def __repr__(self):
20588 
    L = ['%s=%r' % (key, value)
20589 
      for key, value in self.__dict__.iteritems()]
20590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20591 
 
20592 
  def __eq__(self, other):
20593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20594 
 
20595 
  def __ne__(self, other):
20596 
    return not (self == other)
20597 
 
20598 
class acceptOrdersForItemId_result:
20599 
  """
20600 
  Attributes:
20601 
   - success
20602 
   - ex
20603 
  """
20604 
 
20605 
  thrift_spec = (
20606 
    (0, TType.BOOL, 'success', None, None, ), # 0
20607 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20608 
  )
20609 
 
20610 
  def __init__(self, success=None, ex=None,):
20611 
    self.success = success
20612 
    self.ex = ex
20613 
 
20614 
  def read(self, iprot):
20615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20617 
      return
20618 
    iprot.readStructBegin()
20619 
    while True:
20620 
      (fname, ftype, fid) = iprot.readFieldBegin()
20621 
      if ftype == TType.STOP:
20622 
        break
20623 
      if fid == 0:
20624 
        if ftype == TType.BOOL:
20625 
          self.success = iprot.readBool();
20626 
        else:
20627 
          iprot.skip(ftype)
20628 
      elif fid == 1:
20629 
        if ftype == TType.STRUCT:
20630 
          self.ex = TransactionServiceException()
20631 
          self.ex.read(iprot)
20632 
        else:
20633 
          iprot.skip(ftype)
20634 
      else:
20635 
        iprot.skip(ftype)
20636 
      iprot.readFieldEnd()
20637 
    iprot.readStructEnd()
20638 
 
20639 
  def write(self, oprot):
20640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20642 
      return
20643 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20644 
    if self.success is not None:
20645 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20646 
      oprot.writeBool(self.success)
20647 
      oprot.writeFieldEnd()
20648 
    if self.ex is not None:
20649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20650 
      self.ex.write(oprot)
20651 
      oprot.writeFieldEnd()
20652 
    oprot.writeFieldStop()
20653 
    oprot.writeStructEnd()
20654 
 
20655 
  def validate(self):
20656 
    return
20657 
 
20658 
 
20659 
  def __repr__(self):
20660 
    L = ['%s=%r' % (key, value)
20661 
      for key, value in self.__dict__.iteritems()]
20662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20663 
 
20664 
  def __eq__(self, other):
20665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20666 
 
20667 
  def __ne__(self, other):
20668 
    return not (self == other)
4303 rajveer 20669 
 
20670 
class markOrdersAsPORaised_args:
20671 
  """
20672 
  Attributes:
20673 
   - vendorId
20674 
   - itemId
20675 
   - quantity
20676 
   - estimate
4369 rajveer 20677 
   - isReminder
4303 rajveer 20678 
  """
20679 
 
20680 
  thrift_spec = (
20681 
    None, # 0
20682 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20683 
    (2, TType.I64, 'itemId', None, None, ), # 2
20684 
    (3, TType.I64, 'quantity', None, None, ), # 3
20685 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20686 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20687 
  )
20688 
 
4369 rajveer 20689 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20690 
    self.vendorId = vendorId
20691 
    self.itemId = itemId
20692 
    self.quantity = quantity
20693 
    self.estimate = estimate
4369 rajveer 20694 
    self.isReminder = isReminder
4303 rajveer 20695 
 
20696 
  def read(self, iprot):
20697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20699 
      return
20700 
    iprot.readStructBegin()
20701 
    while True:
20702 
      (fname, ftype, fid) = iprot.readFieldBegin()
20703 
      if ftype == TType.STOP:
20704 
        break
20705 
      if fid == 1:
20706 
        if ftype == TType.I64:
20707 
          self.vendorId = iprot.readI64();
20708 
        else:
20709 
          iprot.skip(ftype)
20710 
      elif fid == 2:
20711 
        if ftype == TType.I64:
20712 
          self.itemId = iprot.readI64();
20713 
        else:
20714 
          iprot.skip(ftype)
20715 
      elif fid == 3:
20716 
        if ftype == TType.I64:
20717 
          self.quantity = iprot.readI64();
20718 
        else:
20719 
          iprot.skip(ftype)
20720 
      elif fid == 4:
20721 
        if ftype == TType.I64:
20722 
          self.estimate = iprot.readI64();
20723 
        else:
20724 
          iprot.skip(ftype)
4369 rajveer 20725 
      elif fid == 5:
20726 
        if ftype == TType.BOOL:
20727 
          self.isReminder = iprot.readBool();
20728 
        else:
20729 
          iprot.skip(ftype)
4303 rajveer 20730 
      else:
20731 
        iprot.skip(ftype)
20732 
      iprot.readFieldEnd()
20733 
    iprot.readStructEnd()
20734 
 
20735 
  def write(self, oprot):
20736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20738 
      return
20739 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20740 
    if self.vendorId is not None:
20741 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20742 
      oprot.writeI64(self.vendorId)
20743 
      oprot.writeFieldEnd()
20744 
    if self.itemId is not None:
20745 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20746 
      oprot.writeI64(self.itemId)
20747 
      oprot.writeFieldEnd()
20748 
    if self.quantity is not None:
20749 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20750 
      oprot.writeI64(self.quantity)
20751 
      oprot.writeFieldEnd()
20752 
    if self.estimate is not None:
20753 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20754 
      oprot.writeI64(self.estimate)
20755 
      oprot.writeFieldEnd()
4369 rajveer 20756 
    if self.isReminder is not None:
20757 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20758 
      oprot.writeBool(self.isReminder)
20759 
      oprot.writeFieldEnd()
4303 rajveer 20760 
    oprot.writeFieldStop()
20761 
    oprot.writeStructEnd()
20762 
 
20763 
  def validate(self):
20764 
    return
20765 
 
20766 
 
20767 
  def __repr__(self):
20768 
    L = ['%s=%r' % (key, value)
20769 
      for key, value in self.__dict__.iteritems()]
20770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20771 
 
20772 
  def __eq__(self, other):
20773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20774 
 
20775 
  def __ne__(self, other):
20776 
    return not (self == other)
20777 
 
20778 
class markOrdersAsPORaised_result:
20779 
  """
20780 
  Attributes:
20781 
   - ex
20782 
  """
20783 
 
20784 
  thrift_spec = (
20785 
    None, # 0
20786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20787 
  )
20788 
 
20789 
  def __init__(self, ex=None,):
20790 
    self.ex = ex
20791 
 
20792 
  def read(self, iprot):
20793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20795 
      return
20796 
    iprot.readStructBegin()
20797 
    while True:
20798 
      (fname, ftype, fid) = iprot.readFieldBegin()
20799 
      if ftype == TType.STOP:
20800 
        break
20801 
      if fid == 1:
20802 
        if ftype == TType.STRUCT:
20803 
          self.ex = TransactionServiceException()
20804 
          self.ex.read(iprot)
20805 
        else:
20806 
          iprot.skip(ftype)
20807 
      else:
20808 
        iprot.skip(ftype)
20809 
      iprot.readFieldEnd()
20810 
    iprot.readStructEnd()
20811 
 
20812 
  def write(self, oprot):
20813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20815 
      return
20816 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20817 
    if self.ex is not None:
20818 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20819 
      self.ex.write(oprot)
20820 
      oprot.writeFieldEnd()
20821 
    oprot.writeFieldStop()
20822 
    oprot.writeStructEnd()
20823 
 
20824 
  def validate(self):
20825 
    return
20826 
 
20827 
 
20828 
  def __repr__(self):
20829 
    L = ['%s=%r' % (key, value)
20830 
      for key, value in self.__dict__.iteritems()]
20831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20832 
 
20833 
  def __eq__(self, other):
20834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20835 
 
20836 
  def __ne__(self, other):
20837 
    return not (self == other)
20838 
 
20839 
class markOrdersAsReversalInitiated_args:
20840 
  """
20841 
  Attributes:
20842 
   - vendorId
20843 
   - itemId
20844 
   - quantity
20845 
   - estimate
4369 rajveer 20846 
   - isReminder
4303 rajveer 20847 
  """
20848 
 
20849 
  thrift_spec = (
20850 
    None, # 0
20851 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20852 
    (2, TType.I64, 'itemId', None, None, ), # 2
20853 
    (3, TType.I64, 'quantity', None, None, ), # 3
20854 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20855 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20856 
  )
20857 
 
4369 rajveer 20858 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20859 
    self.vendorId = vendorId
20860 
    self.itemId = itemId
20861 
    self.quantity = quantity
20862 
    self.estimate = estimate
4369 rajveer 20863 
    self.isReminder = isReminder
4303 rajveer 20864 
 
20865 
  def read(self, iprot):
20866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20868 
      return
20869 
    iprot.readStructBegin()
20870 
    while True:
20871 
      (fname, ftype, fid) = iprot.readFieldBegin()
20872 
      if ftype == TType.STOP:
20873 
        break
20874 
      if fid == 1:
20875 
        if ftype == TType.I64:
20876 
          self.vendorId = iprot.readI64();
20877 
        else:
20878 
          iprot.skip(ftype)
20879 
      elif fid == 2:
20880 
        if ftype == TType.I64:
20881 
          self.itemId = iprot.readI64();
20882 
        else:
20883 
          iprot.skip(ftype)
20884 
      elif fid == 3:
20885 
        if ftype == TType.I64:
20886 
          self.quantity = iprot.readI64();
20887 
        else:
20888 
          iprot.skip(ftype)
20889 
      elif fid == 4:
20890 
        if ftype == TType.I64:
20891 
          self.estimate = iprot.readI64();
20892 
        else:
20893 
          iprot.skip(ftype)
4369 rajveer 20894 
      elif fid == 5:
20895 
        if ftype == TType.BOOL:
20896 
          self.isReminder = iprot.readBool();
20897 
        else:
20898 
          iprot.skip(ftype)
4303 rajveer 20899 
      else:
20900 
        iprot.skip(ftype)
20901 
      iprot.readFieldEnd()
20902 
    iprot.readStructEnd()
20903 
 
20904 
  def write(self, oprot):
20905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20907 
      return
20908 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
20909 
    if self.vendorId is not None:
20910 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20911 
      oprot.writeI64(self.vendorId)
20912 
      oprot.writeFieldEnd()
20913 
    if self.itemId is not None:
20914 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20915 
      oprot.writeI64(self.itemId)
20916 
      oprot.writeFieldEnd()
20917 
    if self.quantity is not None:
20918 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20919 
      oprot.writeI64(self.quantity)
20920 
      oprot.writeFieldEnd()
20921 
    if self.estimate is not None:
20922 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20923 
      oprot.writeI64(self.estimate)
20924 
      oprot.writeFieldEnd()
4369 rajveer 20925 
    if self.isReminder is not None:
20926 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20927 
      oprot.writeBool(self.isReminder)
20928 
      oprot.writeFieldEnd()
4303 rajveer 20929 
    oprot.writeFieldStop()
20930 
    oprot.writeStructEnd()
20931 
 
20932 
  def validate(self):
20933 
    return
20934 
 
20935 
 
20936 
  def __repr__(self):
20937 
    L = ['%s=%r' % (key, value)
20938 
      for key, value in self.__dict__.iteritems()]
20939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20940 
 
20941 
  def __eq__(self, other):
20942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20943 
 
20944 
  def __ne__(self, other):
20945 
    return not (self == other)
20946 
 
20947 
class markOrdersAsReversalInitiated_result:
20948 
  """
20949 
  Attributes:
20950 
   - ex
20951 
  """
20952 
 
20953 
  thrift_spec = (
20954 
    None, # 0
20955 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20956 
  )
20957 
 
20958 
  def __init__(self, ex=None,):
20959 
    self.ex = ex
20960 
 
20961 
  def read(self, iprot):
20962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20964 
      return
20965 
    iprot.readStructBegin()
20966 
    while True:
20967 
      (fname, ftype, fid) = iprot.readFieldBegin()
20968 
      if ftype == TType.STOP:
20969 
        break
20970 
      if fid == 1:
20971 
        if ftype == TType.STRUCT:
20972 
          self.ex = TransactionServiceException()
20973 
          self.ex.read(iprot)
20974 
        else:
20975 
          iprot.skip(ftype)
20976 
      else:
20977 
        iprot.skip(ftype)
20978 
      iprot.readFieldEnd()
20979 
    iprot.readStructEnd()
20980 
 
20981 
  def write(self, oprot):
20982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20984 
      return
20985 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20986 
    if self.ex is not None:
20987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20988 
      self.ex.write(oprot)
20989 
      oprot.writeFieldEnd()
20990 
    oprot.writeFieldStop()
20991 
    oprot.writeStructEnd()
20992 
 
20993 
  def validate(self):
20994 
    return
20995 
 
20996 
 
20997 
  def __repr__(self):
20998 
    L = ['%s=%r' % (key, value)
20999 
      for key, value in self.__dict__.iteritems()]
21000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21001 
 
21002 
  def __eq__(self, other):
21003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21004 
 
21005 
  def __ne__(self, other):
21006 
    return not (self == other)
21007 
 
21008 
class markOrdersAsNotAvailabke_args:
21009 
  """
21010 
  Attributes:
21011 
   - vendorId
21012 
   - itemId
21013 
   - quantity
21014 
   - estimate
4369 rajveer 21015 
   - isReminder
4303 rajveer 21016 
  """
21017 
 
21018 
  thrift_spec = (
21019 
    None, # 0
21020 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21021 
    (2, TType.I64, 'itemId', None, None, ), # 2
21022 
    (3, TType.I64, 'quantity', None, None, ), # 3
21023 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21024 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21025 
  )
21026 
 
4369 rajveer 21027 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21028 
    self.vendorId = vendorId
21029 
    self.itemId = itemId
21030 
    self.quantity = quantity
21031 
    self.estimate = estimate
4369 rajveer 21032 
    self.isReminder = isReminder
4303 rajveer 21033 
 
21034 
  def read(self, iprot):
21035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21037 
      return
21038 
    iprot.readStructBegin()
21039 
    while True:
21040 
      (fname, ftype, fid) = iprot.readFieldBegin()
21041 
      if ftype == TType.STOP:
21042 
        break
21043 
      if fid == 1:
21044 
        if ftype == TType.I64:
21045 
          self.vendorId = iprot.readI64();
21046 
        else:
21047 
          iprot.skip(ftype)
21048 
      elif fid == 2:
21049 
        if ftype == TType.I64:
21050 
          self.itemId = iprot.readI64();
21051 
        else:
21052 
          iprot.skip(ftype)
21053 
      elif fid == 3:
21054 
        if ftype == TType.I64:
21055 
          self.quantity = iprot.readI64();
21056 
        else:
21057 
          iprot.skip(ftype)
21058 
      elif fid == 4:
21059 
        if ftype == TType.I64:
21060 
          self.estimate = iprot.readI64();
21061 
        else:
21062 
          iprot.skip(ftype)
4369 rajveer 21063 
      elif fid == 5:
21064 
        if ftype == TType.BOOL:
21065 
          self.isReminder = iprot.readBool();
21066 
        else:
21067 
          iprot.skip(ftype)
4303 rajveer 21068 
      else:
21069 
        iprot.skip(ftype)
21070 
      iprot.readFieldEnd()
21071 
    iprot.readStructEnd()
21072 
 
21073 
  def write(self, oprot):
21074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21076 
      return
21077 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21078 
    if self.vendorId is not None:
21079 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21080 
      oprot.writeI64(self.vendorId)
21081 
      oprot.writeFieldEnd()
21082 
    if self.itemId is not None:
21083 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21084 
      oprot.writeI64(self.itemId)
21085 
      oprot.writeFieldEnd()
21086 
    if self.quantity is not None:
21087 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21088 
      oprot.writeI64(self.quantity)
21089 
      oprot.writeFieldEnd()
21090 
    if self.estimate is not None:
21091 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21092 
      oprot.writeI64(self.estimate)
21093 
      oprot.writeFieldEnd()
4369 rajveer 21094 
    if self.isReminder is not None:
21095 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21096 
      oprot.writeBool(self.isReminder)
21097 
      oprot.writeFieldEnd()
4303 rajveer 21098 
    oprot.writeFieldStop()
21099 
    oprot.writeStructEnd()
21100 
 
21101 
  def validate(self):
21102 
    return
21103 
 
21104 
 
21105 
  def __repr__(self):
21106 
    L = ['%s=%r' % (key, value)
21107 
      for key, value in self.__dict__.iteritems()]
21108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21109 
 
21110 
  def __eq__(self, other):
21111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21112 
 
21113 
  def __ne__(self, other):
21114 
    return not (self == other)
21115 
 
21116 
class markOrdersAsNotAvailabke_result:
21117 
  """
21118 
  Attributes:
21119 
   - ex
21120 
  """
21121 
 
21122 
  thrift_spec = (
21123 
    None, # 0
21124 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21125 
  )
21126 
 
21127 
  def __init__(self, ex=None,):
21128 
    self.ex = ex
21129 
 
21130 
  def read(self, iprot):
21131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21133 
      return
21134 
    iprot.readStructBegin()
21135 
    while True:
21136 
      (fname, ftype, fid) = iprot.readFieldBegin()
21137 
      if ftype == TType.STOP:
21138 
        break
21139 
      if fid == 1:
21140 
        if ftype == TType.STRUCT:
21141 
          self.ex = TransactionServiceException()
21142 
          self.ex.read(iprot)
21143 
        else:
21144 
          iprot.skip(ftype)
21145 
      else:
21146 
        iprot.skip(ftype)
21147 
      iprot.readFieldEnd()
21148 
    iprot.readStructEnd()
21149 
 
21150 
  def write(self, oprot):
21151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21153 
      return
21154 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21155 
    if self.ex is not None:
21156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21157 
      self.ex.write(oprot)
21158 
      oprot.writeFieldEnd()
21159 
    oprot.writeFieldStop()
21160 
    oprot.writeStructEnd()
21161 
 
21162 
  def validate(self):
21163 
    return
21164 
 
21165 
 
21166 
  def __repr__(self):
21167 
    L = ['%s=%r' % (key, value)
21168 
      for key, value in self.__dict__.iteritems()]
21169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21170 
 
21171 
  def __eq__(self, other):
21172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21173 
 
21174 
  def __ne__(self, other):
21175 
    return not (self == other)
4369 rajveer 21176 
 
21177 
class markOrdersAsTimeout_args:
21178 
  """
21179 
  Attributes:
21180 
   - vendorId
21181 
  """
21182 
 
21183 
  thrift_spec = (
21184 
    None, # 0
21185 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21186 
  )
21187 
 
21188 
  def __init__(self, vendorId=None,):
21189 
    self.vendorId = vendorId
21190 
 
21191 
  def read(self, iprot):
21192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21194 
      return
21195 
    iprot.readStructBegin()
21196 
    while True:
21197 
      (fname, ftype, fid) = iprot.readFieldBegin()
21198 
      if ftype == TType.STOP:
21199 
        break
21200 
      if fid == 1:
21201 
        if ftype == TType.I64:
21202 
          self.vendorId = iprot.readI64();
21203 
        else:
21204 
          iprot.skip(ftype)
21205 
      else:
21206 
        iprot.skip(ftype)
21207 
      iprot.readFieldEnd()
21208 
    iprot.readStructEnd()
21209 
 
21210 
  def write(self, oprot):
21211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21213 
      return
21214 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21215 
    if self.vendorId is not None:
21216 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21217 
      oprot.writeI64(self.vendorId)
21218 
      oprot.writeFieldEnd()
21219 
    oprot.writeFieldStop()
21220 
    oprot.writeStructEnd()
21221 
 
21222 
  def validate(self):
21223 
    return
21224 
 
21225 
 
21226 
  def __repr__(self):
21227 
    L = ['%s=%r' % (key, value)
21228 
      for key, value in self.__dict__.iteritems()]
21229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21230 
 
21231 
  def __eq__(self, other):
21232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21233 
 
21234 
  def __ne__(self, other):
21235 
    return not (self == other)
21236 
 
21237 
class markOrdersAsTimeout_result:
21238 
  """
21239 
  Attributes:
21240 
   - success
21241 
   - ex
21242 
  """
21243 
 
21244 
  thrift_spec = (
21245 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21246 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21247 
  )
21248 
 
21249 
  def __init__(self, success=None, ex=None,):
21250 
    self.success = success
21251 
    self.ex = ex
21252 
 
21253 
  def read(self, iprot):
21254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21256 
      return
21257 
    iprot.readStructBegin()
21258 
    while True:
21259 
      (fname, ftype, fid) = iprot.readFieldBegin()
21260 
      if ftype == TType.STOP:
21261 
        break
21262 
      if fid == 0:
21263 
        if ftype == TType.MAP:
21264 
          self.success = {}
6031 rajveer 21265 
          (_ktype459, _vtype460, _size458 ) = iprot.readMapBegin()
21266 
          for _i462 in xrange(_size458):
21267 
            _key463 = iprot.readI32();
21268 
            _val464 = TimeoutSummary()
21269 
            _val464.read(iprot)
21270 
            self.success[_key463] = _val464
4369 rajveer 21271 
          iprot.readMapEnd()
21272 
        else:
21273 
          iprot.skip(ftype)
21274 
      elif fid == 1:
21275 
        if ftype == TType.STRUCT:
21276 
          self.ex = TransactionServiceException()
21277 
          self.ex.read(iprot)
21278 
        else:
21279 
          iprot.skip(ftype)
21280 
      else:
21281 
        iprot.skip(ftype)
21282 
      iprot.readFieldEnd()
21283 
    iprot.readStructEnd()
21284 
 
21285 
  def write(self, oprot):
21286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21288 
      return
21289 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21290 
    if self.success is not None:
21291 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21292 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6031 rajveer 21293 
      for kiter465,viter466 in self.success.items():
21294 
        oprot.writeI32(kiter465)
21295 
        viter466.write(oprot)
4369 rajveer 21296 
      oprot.writeMapEnd()
21297 
      oprot.writeFieldEnd()
21298 
    if self.ex is not None:
21299 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21300 
      self.ex.write(oprot)
21301 
      oprot.writeFieldEnd()
21302 
    oprot.writeFieldStop()
21303 
    oprot.writeStructEnd()
21304 
 
21305 
  def validate(self):
21306 
    return
21307 
 
21308 
 
21309 
  def __repr__(self):
21310 
    L = ['%s=%r' % (key, value)
21311 
      for key, value in self.__dict__.iteritems()]
21312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21313 
 
21314 
  def __eq__(self, other):
21315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21316 
 
21317 
  def __ne__(self, other):
21318 
    return not (self == other)
4386 anupam.sin 21319 
 
4662 rajveer 21320 
class markOrderAsLostInTransit_args:
21321 
  """
21322 
  Attributes:
21323 
   - orderId
21324 
  """
21325 
 
21326 
  thrift_spec = (
21327 
    None, # 0
21328 
    (1, TType.I64, 'orderId', None, None, ), # 1
21329 
  )
21330 
 
21331 
  def __init__(self, orderId=None,):
21332 
    self.orderId = orderId
21333 
 
21334 
  def read(self, iprot):
21335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21337 
      return
21338 
    iprot.readStructBegin()
21339 
    while True:
21340 
      (fname, ftype, fid) = iprot.readFieldBegin()
21341 
      if ftype == TType.STOP:
21342 
        break
21343 
      if fid == 1:
21344 
        if ftype == TType.I64:
21345 
          self.orderId = iprot.readI64();
21346 
        else:
21347 
          iprot.skip(ftype)
21348 
      else:
21349 
        iprot.skip(ftype)
21350 
      iprot.readFieldEnd()
21351 
    iprot.readStructEnd()
21352 
 
21353 
  def write(self, oprot):
21354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21356 
      return
21357 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21358 
    if self.orderId is not None:
21359 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21360 
      oprot.writeI64(self.orderId)
21361 
      oprot.writeFieldEnd()
21362 
    oprot.writeFieldStop()
21363 
    oprot.writeStructEnd()
21364 
 
21365 
  def validate(self):
21366 
    return
21367 
 
21368 
 
21369 
  def __repr__(self):
21370 
    L = ['%s=%r' % (key, value)
21371 
      for key, value in self.__dict__.iteritems()]
21372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21373 
 
21374 
  def __eq__(self, other):
21375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21376 
 
21377 
  def __ne__(self, other):
21378 
    return not (self == other)
21379 
 
21380 
class markOrderAsLostInTransit_result:
21381 
  """
21382 
  Attributes:
21383 
   - success
21384 
   - ex
21385 
  """
21386 
 
21387 
  thrift_spec = (
21388 
    (0, TType.BOOL, 'success', None, None, ), # 0
21389 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21390 
  )
21391 
 
21392 
  def __init__(self, success=None, ex=None,):
21393 
    self.success = success
21394 
    self.ex = ex
21395 
 
21396 
  def read(self, iprot):
21397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21399 
      return
21400 
    iprot.readStructBegin()
21401 
    while True:
21402 
      (fname, ftype, fid) = iprot.readFieldBegin()
21403 
      if ftype == TType.STOP:
21404 
        break
21405 
      if fid == 0:
21406 
        if ftype == TType.BOOL:
21407 
          self.success = iprot.readBool();
21408 
        else:
21409 
          iprot.skip(ftype)
21410 
      elif fid == 1:
21411 
        if ftype == TType.STRUCT:
21412 
          self.ex = TransactionServiceException()
21413 
          self.ex.read(iprot)
21414 
        else:
21415 
          iprot.skip(ftype)
21416 
      else:
21417 
        iprot.skip(ftype)
21418 
      iprot.readFieldEnd()
21419 
    iprot.readStructEnd()
21420 
 
21421 
  def write(self, oprot):
21422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21424 
      return
21425 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21426 
    if self.success is not None:
21427 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21428 
      oprot.writeBool(self.success)
21429 
      oprot.writeFieldEnd()
21430 
    if self.ex is not None:
21431 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21432 
      self.ex.write(oprot)
21433 
      oprot.writeFieldEnd()
21434 
    oprot.writeFieldStop()
21435 
    oprot.writeStructEnd()
21436 
 
21437 
  def validate(self):
21438 
    return
21439 
 
21440 
 
21441 
  def __repr__(self):
21442 
    L = ['%s=%r' % (key, value)
21443 
      for key, value in self.__dict__.iteritems()]
21444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21445 
 
21446 
  def __eq__(self, other):
21447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21448 
 
21449 
  def __ne__(self, other):
21450 
    return not (self == other)
21451 
 
4386 anupam.sin 21452 
class getOrderForAwb_args:
21453 
  """
21454 
  Attributes:
21455 
   - awb
21456 
  """
21457 
 
21458 
  thrift_spec = (
21459 
    None, # 0
21460 
    (1, TType.STRING, 'awb', None, None, ), # 1
21461 
  )
21462 
 
21463 
  def __init__(self, awb=None,):
21464 
    self.awb = awb
21465 
 
21466 
  def read(self, iprot):
21467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21469 
      return
21470 
    iprot.readStructBegin()
21471 
    while True:
21472 
      (fname, ftype, fid) = iprot.readFieldBegin()
21473 
      if ftype == TType.STOP:
21474 
        break
21475 
      if fid == 1:
21476 
        if ftype == TType.STRING:
21477 
          self.awb = iprot.readString();
21478 
        else:
21479 
          iprot.skip(ftype)
21480 
      else:
21481 
        iprot.skip(ftype)
21482 
      iprot.readFieldEnd()
21483 
    iprot.readStructEnd()
21484 
 
21485 
  def write(self, oprot):
21486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21488 
      return
21489 
    oprot.writeStructBegin('getOrderForAwb_args')
21490 
    if self.awb is not None:
21491 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21492 
      oprot.writeString(self.awb)
21493 
      oprot.writeFieldEnd()
21494 
    oprot.writeFieldStop()
21495 
    oprot.writeStructEnd()
21496 
 
21497 
  def validate(self):
21498 
    return
21499 
 
21500 
 
21501 
  def __repr__(self):
21502 
    L = ['%s=%r' % (key, value)
21503 
      for key, value in self.__dict__.iteritems()]
21504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21505 
 
21506 
  def __eq__(self, other):
21507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21508 
 
21509 
  def __ne__(self, other):
21510 
    return not (self == other)
21511 
 
21512 
class getOrderForAwb_result:
21513 
  """
21514 
  Attributes:
21515 
   - success
21516 
   - ex
21517 
  """
21518 
 
21519 
  thrift_spec = (
21520 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21521 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21522 
  )
21523 
 
21524 
  def __init__(self, success=None, ex=None,):
21525 
    self.success = success
21526 
    self.ex = ex
21527 
 
21528 
  def read(self, iprot):
21529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21531 
      return
21532 
    iprot.readStructBegin()
21533 
    while True:
21534 
      (fname, ftype, fid) = iprot.readFieldBegin()
21535 
      if ftype == TType.STOP:
21536 
        break
21537 
      if fid == 0:
21538 
        if ftype == TType.STRUCT:
21539 
          self.success = Order()
21540 
          self.success.read(iprot)
21541 
        else:
21542 
          iprot.skip(ftype)
21543 
      elif fid == 1:
21544 
        if ftype == TType.STRUCT:
21545 
          self.ex = TransactionServiceException()
21546 
          self.ex.read(iprot)
21547 
        else:
21548 
          iprot.skip(ftype)
21549 
      else:
21550 
        iprot.skip(ftype)
21551 
      iprot.readFieldEnd()
21552 
    iprot.readStructEnd()
21553 
 
21554 
  def write(self, oprot):
21555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21557 
      return
21558 
    oprot.writeStructBegin('getOrderForAwb_result')
21559 
    if self.success is not None:
21560 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21561 
      self.success.write(oprot)
21562 
      oprot.writeFieldEnd()
21563 
    if self.ex is not None:
21564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21565 
      self.ex.write(oprot)
21566 
      oprot.writeFieldEnd()
21567 
    oprot.writeFieldStop()
21568 
    oprot.writeStructEnd()
21569 
 
21570 
  def validate(self):
21571 
    return
21572 
 
21573 
 
21574 
  def __repr__(self):
21575 
    L = ['%s=%r' % (key, value)
21576 
      for key, value in self.__dict__.iteritems()]
21577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21578 
 
21579 
  def __eq__(self, other):
21580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21581 
 
21582 
  def __ne__(self, other):
21583 
    return not (self == other)
4506 phani.kuma 21584 
 
21585 
class getOrdersForProviderForStatus_args:
21586 
  """
21587 
  Attributes:
21588 
   - logistics_provider_id
4910 phani.kuma 21589 
   - order_status_list
4506 phani.kuma 21590 
  """
21591 
 
21592 
  thrift_spec = (
21593 
    None, # 0
21594 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21595 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21596 
  )
21597 
 
4910 phani.kuma 21598 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21599 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21600 
    self.order_status_list = order_status_list
4506 phani.kuma 21601 
 
21602 
  def read(self, iprot):
21603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21605 
      return
21606 
    iprot.readStructBegin()
21607 
    while True:
21608 
      (fname, ftype, fid) = iprot.readFieldBegin()
21609 
      if ftype == TType.STOP:
21610 
        break
21611 
      if fid == 1:
21612 
        if ftype == TType.I64:
21613 
          self.logistics_provider_id = iprot.readI64();
21614 
        else:
21615 
          iprot.skip(ftype)
21616 
      elif fid == 2:
4910 phani.kuma 21617 
        if ftype == TType.LIST:
21618 
          self.order_status_list = []
6031 rajveer 21619 
          (_etype470, _size467) = iprot.readListBegin()
21620 
          for _i471 in xrange(_size467):
21621 
            _elem472 = iprot.readI32();
21622 
            self.order_status_list.append(_elem472)
4910 phani.kuma 21623 
          iprot.readListEnd()
4506 phani.kuma 21624 
        else:
21625 
          iprot.skip(ftype)
21626 
      else:
21627 
        iprot.skip(ftype)
21628 
      iprot.readFieldEnd()
21629 
    iprot.readStructEnd()
21630 
 
21631 
  def write(self, oprot):
21632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21634 
      return
21635 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21636 
    if self.logistics_provider_id is not None:
21637 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21638 
      oprot.writeI64(self.logistics_provider_id)
21639 
      oprot.writeFieldEnd()
4910 phani.kuma 21640 
    if self.order_status_list is not None:
21641 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21642 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6031 rajveer 21643 
      for iter473 in self.order_status_list:
21644 
        oprot.writeI32(iter473)
4910 phani.kuma 21645 
      oprot.writeListEnd()
4506 phani.kuma 21646 
      oprot.writeFieldEnd()
21647 
    oprot.writeFieldStop()
21648 
    oprot.writeStructEnd()
21649 
 
21650 
  def validate(self):
21651 
    return
21652 
 
21653 
 
21654 
  def __repr__(self):
21655 
    L = ['%s=%r' % (key, value)
21656 
      for key, value in self.__dict__.iteritems()]
21657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21658 
 
21659 
  def __eq__(self, other):
21660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21661 
 
21662 
  def __ne__(self, other):
21663 
    return not (self == other)
21664 
 
21665 
class getOrdersForProviderForStatus_result:
21666 
  """
21667 
  Attributes:
21668 
   - success
21669 
   - ex
21670 
  """
21671 
 
21672 
  thrift_spec = (
21673 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21674 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21675 
  )
21676 
 
21677 
  def __init__(self, success=None, ex=None,):
21678 
    self.success = success
21679 
    self.ex = ex
21680 
 
21681 
  def read(self, iprot):
21682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21684 
      return
21685 
    iprot.readStructBegin()
21686 
    while True:
21687 
      (fname, ftype, fid) = iprot.readFieldBegin()
21688 
      if ftype == TType.STOP:
21689 
        break
21690 
      if fid == 0:
21691 
        if ftype == TType.LIST:
21692 
          self.success = []
6031 rajveer 21693 
          (_etype477, _size474) = iprot.readListBegin()
21694 
          for _i478 in xrange(_size474):
21695 
            _elem479 = Order()
21696 
            _elem479.read(iprot)
21697 
            self.success.append(_elem479)
4506 phani.kuma 21698 
          iprot.readListEnd()
21699 
        else:
21700 
          iprot.skip(ftype)
21701 
      elif fid == 1:
21702 
        if ftype == TType.STRUCT:
21703 
          self.ex = TransactionServiceException()
21704 
          self.ex.read(iprot)
21705 
        else:
21706 
          iprot.skip(ftype)
21707 
      else:
21708 
        iprot.skip(ftype)
21709 
      iprot.readFieldEnd()
21710 
    iprot.readStructEnd()
21711 
 
21712 
  def write(self, oprot):
21713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21715 
      return
21716 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21717 
    if self.success is not None:
21718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21719 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21720 
      for iter480 in self.success:
21721 
        iter480.write(oprot)
4506 phani.kuma 21722 
      oprot.writeListEnd()
21723 
      oprot.writeFieldEnd()
21724 
    if self.ex is not None:
21725 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21726 
      self.ex.write(oprot)
21727 
      oprot.writeFieldEnd()
21728 
    oprot.writeFieldStop()
21729 
    oprot.writeStructEnd()
21730 
 
21731 
  def validate(self):
21732 
    return
21733 
 
21734 
 
21735 
  def __repr__(self):
21736 
    L = ['%s=%r' % (key, value)
21737 
      for key, value in self.__dict__.iteritems()]
21738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21739 
 
21740 
  def __eq__(self, other):
21741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21742 
 
21743 
  def __ne__(self, other):
21744 
    return not (self == other)
4600 varun.gupt 21745 
 
21746 
class getBilledOrdersForVendor_args:
21747 
  """
21748 
  Attributes:
21749 
   - vendorId
21750 
   - billingDateFrom
21751 
   - billingDateTo
21752 
  """
21753 
 
21754 
  thrift_spec = (
21755 
    None, # 0
21756 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21757 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21758 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21759 
  )
21760 
 
21761 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21762 
    self.vendorId = vendorId
21763 
    self.billingDateFrom = billingDateFrom
21764 
    self.billingDateTo = billingDateTo
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 == 1:
21776 
        if ftype == TType.I64:
21777 
          self.vendorId = iprot.readI64();
21778 
        else:
21779 
          iprot.skip(ftype)
21780 
      elif fid == 2:
21781 
        if ftype == TType.I64:
21782 
          self.billingDateFrom = iprot.readI64();
21783 
        else:
21784 
          iprot.skip(ftype)
21785 
      elif fid == 3:
21786 
        if ftype == TType.I64:
21787 
          self.billingDateTo = iprot.readI64();
21788 
        else:
21789 
          iprot.skip(ftype)
21790 
      else:
21791 
        iprot.skip(ftype)
21792 
      iprot.readFieldEnd()
21793 
    iprot.readStructEnd()
21794 
 
21795 
  def write(self, oprot):
21796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21798 
      return
21799 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21800 
    if self.vendorId is not None:
21801 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21802 
      oprot.writeI64(self.vendorId)
21803 
      oprot.writeFieldEnd()
21804 
    if self.billingDateFrom is not None:
21805 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21806 
      oprot.writeI64(self.billingDateFrom)
21807 
      oprot.writeFieldEnd()
21808 
    if self.billingDateTo is not None:
21809 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21810 
      oprot.writeI64(self.billingDateTo)
21811 
      oprot.writeFieldEnd()
21812 
    oprot.writeFieldStop()
21813 
    oprot.writeStructEnd()
21814 
 
21815 
  def validate(self):
21816 
    return
21817 
 
21818 
 
21819 
  def __repr__(self):
21820 
    L = ['%s=%r' % (key, value)
21821 
      for key, value in self.__dict__.iteritems()]
21822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21823 
 
21824 
  def __eq__(self, other):
21825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21826 
 
21827 
  def __ne__(self, other):
21828 
    return not (self == other)
21829 
 
21830 
class getBilledOrdersForVendor_result:
21831 
  """
21832 
  Attributes:
21833 
   - success
21834 
   - ex
21835 
  """
21836 
 
21837 
  thrift_spec = (
21838 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21840 
  )
21841 
 
21842 
  def __init__(self, success=None, ex=None,):
21843 
    self.success = success
21844 
    self.ex = ex
21845 
 
21846 
  def read(self, iprot):
21847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21849 
      return
21850 
    iprot.readStructBegin()
21851 
    while True:
21852 
      (fname, ftype, fid) = iprot.readFieldBegin()
21853 
      if ftype == TType.STOP:
21854 
        break
21855 
      if fid == 0:
21856 
        if ftype == TType.LIST:
21857 
          self.success = []
6031 rajveer 21858 
          (_etype484, _size481) = iprot.readListBegin()
21859 
          for _i485 in xrange(_size481):
21860 
            _elem486 = Order()
21861 
            _elem486.read(iprot)
21862 
            self.success.append(_elem486)
4600 varun.gupt 21863 
          iprot.readListEnd()
21864 
        else:
21865 
          iprot.skip(ftype)
21866 
      elif fid == 1:
21867 
        if ftype == TType.STRUCT:
21868 
          self.ex = TransactionServiceException()
21869 
          self.ex.read(iprot)
21870 
        else:
21871 
          iprot.skip(ftype)
21872 
      else:
21873 
        iprot.skip(ftype)
21874 
      iprot.readFieldEnd()
21875 
    iprot.readStructEnd()
21876 
 
21877 
  def write(self, oprot):
21878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21880 
      return
21881 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
21882 
    if self.success is not None:
21883 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21884 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21885 
      for iter487 in self.success:
21886 
        iter487.write(oprot)
4600 varun.gupt 21887 
      oprot.writeListEnd()
21888 
      oprot.writeFieldEnd()
21889 
    if self.ex is not None:
21890 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21891 
      self.ex.write(oprot)
21892 
      oprot.writeFieldEnd()
21893 
    oprot.writeFieldStop()
21894 
    oprot.writeStructEnd()
21895 
 
21896 
  def validate(self):
21897 
    return
21898 
 
21899 
 
21900 
  def __repr__(self):
21901 
    L = ['%s=%r' % (key, value)
21902 
      for key, value in self.__dict__.iteritems()]
21903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21904 
 
21905 
  def __eq__(self, other):
21906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21907 
 
21908 
  def __ne__(self, other):
21909 
    return not (self == other)
21910 
 
4607 rajveer 21911 
class getSlippedSippingDateOrders_args:
21912 
 
21913 
  thrift_spec = (
21914 
  )
21915 
 
21916 
  def read(self, iprot):
21917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21919 
      return
21920 
    iprot.readStructBegin()
21921 
    while True:
21922 
      (fname, ftype, fid) = iprot.readFieldBegin()
21923 
      if ftype == TType.STOP:
21924 
        break
21925 
      else:
21926 
        iprot.skip(ftype)
21927 
      iprot.readFieldEnd()
21928 
    iprot.readStructEnd()
21929 
 
21930 
  def write(self, oprot):
21931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21933 
      return
21934 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
21935 
    oprot.writeFieldStop()
21936 
    oprot.writeStructEnd()
21937 
 
21938 
  def validate(self):
21939 
    return
21940 
 
21941 
 
21942 
  def __repr__(self):
21943 
    L = ['%s=%r' % (key, value)
21944 
      for key, value in self.__dict__.iteritems()]
21945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21946 
 
21947 
  def __eq__(self, other):
21948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21949 
 
21950 
  def __ne__(self, other):
21951 
    return not (self == other)
21952 
 
21953 
class getSlippedSippingDateOrders_result:
21954 
  """
21955 
  Attributes:
21956 
   - success
21957 
   - ex
21958 
  """
21959 
 
21960 
  thrift_spec = (
21961 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21963 
  )
21964 
 
21965 
  def __init__(self, success=None, ex=None,):
21966 
    self.success = success
21967 
    self.ex = ex
21968 
 
21969 
  def read(self, iprot):
21970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21972 
      return
21973 
    iprot.readStructBegin()
21974 
    while True:
21975 
      (fname, ftype, fid) = iprot.readFieldBegin()
21976 
      if ftype == TType.STOP:
21977 
        break
21978 
      if fid == 0:
21979 
        if ftype == TType.LIST:
21980 
          self.success = []
6031 rajveer 21981 
          (_etype491, _size488) = iprot.readListBegin()
21982 
          for _i492 in xrange(_size488):
21983 
            _elem493 = Order()
21984 
            _elem493.read(iprot)
21985 
            self.success.append(_elem493)
4607 rajveer 21986 
          iprot.readListEnd()
21987 
        else:
21988 
          iprot.skip(ftype)
21989 
      elif fid == 1:
21990 
        if ftype == TType.STRUCT:
21991 
          self.ex = TransactionServiceException()
21992 
          self.ex.read(iprot)
21993 
        else:
21994 
          iprot.skip(ftype)
21995 
      else:
21996 
        iprot.skip(ftype)
21997 
      iprot.readFieldEnd()
21998 
    iprot.readStructEnd()
21999 
 
22000 
  def write(self, oprot):
22001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22003 
      return
22004 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22005 
    if self.success is not None:
22006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22007 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22008 
      for iter494 in self.success:
22009 
        iter494.write(oprot)
4607 rajveer 22010 
      oprot.writeListEnd()
22011 
      oprot.writeFieldEnd()
22012 
    if self.ex is not None:
22013 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22014 
      self.ex.write(oprot)
22015 
      oprot.writeFieldEnd()
22016 
    oprot.writeFieldStop()
22017 
    oprot.writeStructEnd()
22018 
 
22019 
  def validate(self):
22020 
    return
22021 
 
22022 
 
22023 
  def __repr__(self):
22024 
    L = ['%s=%r' % (key, value)
22025 
      for key, value in self.__dict__.iteritems()]
22026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22027 
 
22028 
  def __eq__(self, other):
22029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22030 
 
22031 
  def __ne__(self, other):
22032 
    return not (self == other)
22033 
 
4709 rajveer 22034 
class getCancelledOrders_args:
22035 
  """
22036 
  Attributes:
22037 
   - cancelDateFrom
22038 
   - cancelDateTo
22039 
  """
22040 
 
22041 
  thrift_spec = (
22042 
    None, # 0
22043 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22044 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22045 
  )
22046 
 
22047 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22048 
    self.cancelDateFrom = cancelDateFrom
22049 
    self.cancelDateTo = cancelDateTo
22050 
 
22051 
  def read(self, iprot):
22052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22054 
      return
22055 
    iprot.readStructBegin()
22056 
    while True:
22057 
      (fname, ftype, fid) = iprot.readFieldBegin()
22058 
      if ftype == TType.STOP:
22059 
        break
22060 
      if fid == 1:
22061 
        if ftype == TType.I64:
22062 
          self.cancelDateFrom = iprot.readI64();
22063 
        else:
22064 
          iprot.skip(ftype)
22065 
      elif fid == 2:
22066 
        if ftype == TType.I64:
22067 
          self.cancelDateTo = iprot.readI64();
22068 
        else:
22069 
          iprot.skip(ftype)
22070 
      else:
22071 
        iprot.skip(ftype)
22072 
      iprot.readFieldEnd()
22073 
    iprot.readStructEnd()
22074 
 
22075 
  def write(self, oprot):
22076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22078 
      return
22079 
    oprot.writeStructBegin('getCancelledOrders_args')
22080 
    if self.cancelDateFrom is not None:
22081 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22082 
      oprot.writeI64(self.cancelDateFrom)
22083 
      oprot.writeFieldEnd()
22084 
    if self.cancelDateTo is not None:
22085 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22086 
      oprot.writeI64(self.cancelDateTo)
22087 
      oprot.writeFieldEnd()
22088 
    oprot.writeFieldStop()
22089 
    oprot.writeStructEnd()
22090 
 
22091 
  def validate(self):
22092 
    return
22093 
 
22094 
 
22095 
  def __repr__(self):
22096 
    L = ['%s=%r' % (key, value)
22097 
      for key, value in self.__dict__.iteritems()]
22098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22099 
 
22100 
  def __eq__(self, other):
22101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22102 
 
22103 
  def __ne__(self, other):
22104 
    return not (self == other)
22105 
 
22106 
class getCancelledOrders_result:
22107 
  """
22108 
  Attributes:
22109 
   - success
22110 
   - ex
22111 
  """
22112 
 
22113 
  thrift_spec = (
22114 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22115 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22116 
  )
22117 
 
22118 
  def __init__(self, success=None, ex=None,):
22119 
    self.success = success
22120 
    self.ex = ex
22121 
 
22122 
  def read(self, iprot):
22123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22125 
      return
22126 
    iprot.readStructBegin()
22127 
    while True:
22128 
      (fname, ftype, fid) = iprot.readFieldBegin()
22129 
      if ftype == TType.STOP:
22130 
        break
22131 
      if fid == 0:
22132 
        if ftype == TType.LIST:
22133 
          self.success = []
6031 rajveer 22134 
          (_etype498, _size495) = iprot.readListBegin()
22135 
          for _i499 in xrange(_size495):
22136 
            _elem500 = Order()
22137 
            _elem500.read(iprot)
22138 
            self.success.append(_elem500)
4709 rajveer 22139 
          iprot.readListEnd()
22140 
        else:
22141 
          iprot.skip(ftype)
22142 
      elif fid == 1:
22143 
        if ftype == TType.STRUCT:
22144 
          self.ex = TransactionServiceException()
22145 
          self.ex.read(iprot)
22146 
        else:
22147 
          iprot.skip(ftype)
22148 
      else:
22149 
        iprot.skip(ftype)
22150 
      iprot.readFieldEnd()
22151 
    iprot.readStructEnd()
22152 
 
22153 
  def write(self, oprot):
22154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22156 
      return
22157 
    oprot.writeStructBegin('getCancelledOrders_result')
22158 
    if self.success is not None:
22159 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22160 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22161 
      for iter501 in self.success:
22162 
        iter501.write(oprot)
4709 rajveer 22163 
      oprot.writeListEnd()
22164 
      oprot.writeFieldEnd()
22165 
    if self.ex is not None:
22166 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22167 
      self.ex.write(oprot)
22168 
      oprot.writeFieldEnd()
22169 
    oprot.writeFieldStop()
22170 
    oprot.writeStructEnd()
22171 
 
22172 
  def validate(self):
22173 
    return
22174 
 
22175 
 
22176 
  def __repr__(self):
22177 
    L = ['%s=%r' % (key, value)
22178 
      for key, value in self.__dict__.iteritems()]
22179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22180 
 
22181 
  def __eq__(self, other):
22182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22183 
 
22184 
  def __ne__(self, other):
22185 
    return not (self == other)
22186 
 
4600 varun.gupt 22187 
class saveBluedartSettlements_args:
22188 
  """
22189 
  Attributes:
22190 
   - mapAWBAndAmount
22191 
  """
22192 
 
22193 
  thrift_spec = (
22194 
    None, # 0
22195 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22196 
  )
22197 
 
22198 
  def __init__(self, mapAWBAndAmount=None,):
22199 
    self.mapAWBAndAmount = mapAWBAndAmount
22200 
 
22201 
  def read(self, iprot):
22202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22204 
      return
22205 
    iprot.readStructBegin()
22206 
    while True:
22207 
      (fname, ftype, fid) = iprot.readFieldBegin()
22208 
      if ftype == TType.STOP:
22209 
        break
22210 
      if fid == 1:
22211 
        if ftype == TType.MAP:
22212 
          self.mapAWBAndAmount = {}
6031 rajveer 22213 
          (_ktype503, _vtype504, _size502 ) = iprot.readMapBegin()
22214 
          for _i506 in xrange(_size502):
22215 
            _key507 = iprot.readI64();
22216 
            _val508 = iprot.readDouble();
22217 
            self.mapAWBAndAmount[_key507] = _val508
4600 varun.gupt 22218 
          iprot.readMapEnd()
22219 
        else:
22220 
          iprot.skip(ftype)
22221 
      else:
22222 
        iprot.skip(ftype)
22223 
      iprot.readFieldEnd()
22224 
    iprot.readStructEnd()
22225 
 
22226 
  def write(self, oprot):
22227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22229 
      return
22230 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22231 
    if self.mapAWBAndAmount is not None:
22232 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22233 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6031 rajveer 22234 
      for kiter509,viter510 in self.mapAWBAndAmount.items():
22235 
        oprot.writeI64(kiter509)
22236 
        oprot.writeDouble(viter510)
4600 varun.gupt 22237 
      oprot.writeMapEnd()
22238 
      oprot.writeFieldEnd()
22239 
    oprot.writeFieldStop()
22240 
    oprot.writeStructEnd()
22241 
 
22242 
  def validate(self):
22243 
    return
22244 
 
22245 
 
22246 
  def __repr__(self):
22247 
    L = ['%s=%r' % (key, value)
22248 
      for key, value in self.__dict__.iteritems()]
22249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22250 
 
22251 
  def __eq__(self, other):
22252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22253 
 
22254 
  def __ne__(self, other):
22255 
    return not (self == other)
22256 
 
22257 
class saveBluedartSettlements_result:
22258 
  """
22259 
  Attributes:
22260 
   - ex
22261 
  """
22262 
 
22263 
  thrift_spec = (
22264 
    None, # 0
22265 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22266 
  )
22267 
 
22268 
  def __init__(self, ex=None,):
22269 
    self.ex = ex
22270 
 
22271 
  def read(self, iprot):
22272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22274 
      return
22275 
    iprot.readStructBegin()
22276 
    while True:
22277 
      (fname, ftype, fid) = iprot.readFieldBegin()
22278 
      if ftype == TType.STOP:
22279 
        break
22280 
      if fid == 1:
22281 
        if ftype == TType.STRUCT:
22282 
          self.ex = TransactionServiceException()
22283 
          self.ex.read(iprot)
22284 
        else:
22285 
          iprot.skip(ftype)
22286 
      else:
22287 
        iprot.skip(ftype)
22288 
      iprot.readFieldEnd()
22289 
    iprot.readStructEnd()
22290 
 
22291 
  def write(self, oprot):
22292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22294 
      return
22295 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22296 
    if self.ex is not None:
22297 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22298 
      self.ex.write(oprot)
22299 
      oprot.writeFieldEnd()
22300 
    oprot.writeFieldStop()
22301 
    oprot.writeStructEnd()
22302 
 
22303 
  def validate(self):
22304 
    return
22305 
 
22306 
 
22307 
  def __repr__(self):
22308 
    L = ['%s=%r' % (key, value)
22309 
      for key, value in self.__dict__.iteritems()]
22310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22311 
 
22312 
  def __eq__(self, other):
22313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22314 
 
22315 
  def __ne__(self, other):
22316 
    return not (self == other)
22317 
 
22318 
class savePaymentSettlements_args:
22319 
  """
22320 
  Attributes:
22321 
   - settlementDate
22322 
   - paymentGatewayId
4905 varun.gupt 22323 
   - referenceId
4600 varun.gupt 22324 
   - serviceTax
22325 
   - otherCharges
22326 
   - netCollection
22327 
  """
22328 
 
22329 
  thrift_spec = (
22330 
    None, # 0
22331 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22332 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22333 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22334 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22335 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22336 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22337 
  )
22338 
 
4905 varun.gupt 22339 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22340 
    self.settlementDate = settlementDate
22341 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22342 
    self.referenceId = referenceId
4600 varun.gupt 22343 
    self.serviceTax = serviceTax
22344 
    self.otherCharges = otherCharges
22345 
    self.netCollection = netCollection
22346 
 
22347 
  def read(self, iprot):
22348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22350 
      return
22351 
    iprot.readStructBegin()
22352 
    while True:
22353 
      (fname, ftype, fid) = iprot.readFieldBegin()
22354 
      if ftype == TType.STOP:
22355 
        break
22356 
      if fid == 1:
22357 
        if ftype == TType.I64:
22358 
          self.settlementDate = iprot.readI64();
22359 
        else:
22360 
          iprot.skip(ftype)
22361 
      elif fid == 2:
22362 
        if ftype == TType.I64:
22363 
          self.paymentGatewayId = iprot.readI64();
22364 
        else:
22365 
          iprot.skip(ftype)
22366 
      elif fid == 3:
22367 
        if ftype == TType.I64:
4905 varun.gupt 22368 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22369 
        else:
22370 
          iprot.skip(ftype)
22371 
      elif fid == 4:
22372 
        if ftype == TType.DOUBLE:
22373 
          self.serviceTax = iprot.readDouble();
22374 
        else:
22375 
          iprot.skip(ftype)
22376 
      elif fid == 5:
22377 
        if ftype == TType.DOUBLE:
22378 
          self.otherCharges = iprot.readDouble();
22379 
        else:
22380 
          iprot.skip(ftype)
22381 
      elif fid == 6:
22382 
        if ftype == TType.DOUBLE:
22383 
          self.netCollection = iprot.readDouble();
22384 
        else:
22385 
          iprot.skip(ftype)
22386 
      else:
22387 
        iprot.skip(ftype)
22388 
      iprot.readFieldEnd()
22389 
    iprot.readStructEnd()
22390 
 
22391 
  def write(self, oprot):
22392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22394 
      return
22395 
    oprot.writeStructBegin('savePaymentSettlements_args')
22396 
    if self.settlementDate is not None:
22397 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22398 
      oprot.writeI64(self.settlementDate)
22399 
      oprot.writeFieldEnd()
22400 
    if self.paymentGatewayId is not None:
22401 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22402 
      oprot.writeI64(self.paymentGatewayId)
22403 
      oprot.writeFieldEnd()
4905 varun.gupt 22404 
    if self.referenceId is not None:
22405 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22406 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22407 
      oprot.writeFieldEnd()
22408 
    if self.serviceTax is not None:
22409 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22410 
      oprot.writeDouble(self.serviceTax)
22411 
      oprot.writeFieldEnd()
22412 
    if self.otherCharges is not None:
22413 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22414 
      oprot.writeDouble(self.otherCharges)
22415 
      oprot.writeFieldEnd()
22416 
    if self.netCollection is not None:
22417 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22418 
      oprot.writeDouble(self.netCollection)
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)
22437 
 
22438 
class savePaymentSettlements_result:
22439 
  """
22440 
  Attributes:
22441 
   - ex
22442 
  """
22443 
 
22444 
  thrift_spec = (
22445 
    None, # 0
22446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22447 
  )
22448 
 
22449 
  def __init__(self, ex=None,):
22450 
    self.ex = ex
22451 
 
22452 
  def read(self, iprot):
22453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22455 
      return
22456 
    iprot.readStructBegin()
22457 
    while True:
22458 
      (fname, ftype, fid) = iprot.readFieldBegin()
22459 
      if ftype == TType.STOP:
22460 
        break
22461 
      if fid == 1:
22462 
        if ftype == TType.STRUCT:
22463 
          self.ex = TransactionServiceException()
22464 
          self.ex.read(iprot)
22465 
        else:
22466 
          iprot.skip(ftype)
22467 
      else:
22468 
        iprot.skip(ftype)
22469 
      iprot.readFieldEnd()
22470 
    iprot.readStructEnd()
22471 
 
22472 
  def write(self, oprot):
22473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22475 
      return
22476 
    oprot.writeStructBegin('savePaymentSettlements_result')
22477 
    if self.ex is not None:
22478 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22479 
      self.ex.write(oprot)
22480 
      oprot.writeFieldEnd()
22481 
    oprot.writeFieldStop()
22482 
    oprot.writeStructEnd()
22483 
 
22484 
  def validate(self):
22485 
    return
22486 
 
22487 
 
22488 
  def __repr__(self):
22489 
    L = ['%s=%r' % (key, value)
22490 
      for key, value in self.__dict__.iteritems()]
22491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22492 
 
22493 
  def __eq__(self, other):
22494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22495 
 
22496 
  def __ne__(self, other):
22497 
    return not (self == other)
22498 
 
22499 
class saveEBSSettlementSummary_args:
22500 
  """
22501 
  Attributes:
22502 
   - settlementId
22503 
   - settlementDate
22504 
   - transactionDateFrom
22505 
   - transactionDateTo
22506 
   - amount
22507 
  """
22508 
 
22509 
  thrift_spec = (
22510 
    None, # 0
22511 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22512 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22513 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22514 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22515 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22516 
  )
22517 
 
22518 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22519 
    self.settlementId = settlementId
22520 
    self.settlementDate = settlementDate
22521 
    self.transactionDateFrom = transactionDateFrom
22522 
    self.transactionDateTo = transactionDateTo
22523 
    self.amount = amount
22524 
 
22525 
  def read(self, iprot):
22526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22528 
      return
22529 
    iprot.readStructBegin()
22530 
    while True:
22531 
      (fname, ftype, fid) = iprot.readFieldBegin()
22532 
      if ftype == TType.STOP:
22533 
        break
22534 
      if fid == 1:
22535 
        if ftype == TType.I64:
22536 
          self.settlementId = iprot.readI64();
22537 
        else:
22538 
          iprot.skip(ftype)
22539 
      elif fid == 2:
22540 
        if ftype == TType.I64:
22541 
          self.settlementDate = iprot.readI64();
22542 
        else:
22543 
          iprot.skip(ftype)
22544 
      elif fid == 3:
22545 
        if ftype == TType.I64:
22546 
          self.transactionDateFrom = iprot.readI64();
22547 
        else:
22548 
          iprot.skip(ftype)
22549 
      elif fid == 4:
22550 
        if ftype == TType.I64:
22551 
          self.transactionDateTo = iprot.readI64();
22552 
        else:
22553 
          iprot.skip(ftype)
22554 
      elif fid == 5:
22555 
        if ftype == TType.DOUBLE:
22556 
          self.amount = iprot.readDouble();
22557 
        else:
22558 
          iprot.skip(ftype)
22559 
      else:
22560 
        iprot.skip(ftype)
22561 
      iprot.readFieldEnd()
22562 
    iprot.readStructEnd()
22563 
 
22564 
  def write(self, oprot):
22565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22567 
      return
22568 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22569 
    if self.settlementId is not None:
22570 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22571 
      oprot.writeI64(self.settlementId)
22572 
      oprot.writeFieldEnd()
22573 
    if self.settlementDate is not None:
22574 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22575 
      oprot.writeI64(self.settlementDate)
22576 
      oprot.writeFieldEnd()
22577 
    if self.transactionDateFrom is not None:
22578 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22579 
      oprot.writeI64(self.transactionDateFrom)
22580 
      oprot.writeFieldEnd()
22581 
    if self.transactionDateTo is not None:
22582 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22583 
      oprot.writeI64(self.transactionDateTo)
22584 
      oprot.writeFieldEnd()
22585 
    if self.amount is not None:
22586 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22587 
      oprot.writeDouble(self.amount)
22588 
      oprot.writeFieldEnd()
22589 
    oprot.writeFieldStop()
22590 
    oprot.writeStructEnd()
22591 
 
22592 
  def validate(self):
22593 
    return
22594 
 
22595 
 
22596 
  def __repr__(self):
22597 
    L = ['%s=%r' % (key, value)
22598 
      for key, value in self.__dict__.iteritems()]
22599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22600 
 
22601 
  def __eq__(self, other):
22602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22603 
 
22604 
  def __ne__(self, other):
22605 
    return not (self == other)
22606 
 
22607 
class saveEBSSettlementSummary_result:
22608 
  """
22609 
  Attributes:
22610 
   - ex
22611 
  """
22612 
 
22613 
  thrift_spec = (
22614 
    None, # 0
22615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22616 
  )
22617 
 
22618 
  def __init__(self, ex=None,):
22619 
    self.ex = ex
22620 
 
22621 
  def read(self, iprot):
22622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22624 
      return
22625 
    iprot.readStructBegin()
22626 
    while True:
22627 
      (fname, ftype, fid) = iprot.readFieldBegin()
22628 
      if ftype == TType.STOP:
22629 
        break
22630 
      if fid == 1:
22631 
        if ftype == TType.STRUCT:
22632 
          self.ex = TransactionServiceException()
22633 
          self.ex.read(iprot)
22634 
        else:
22635 
          iprot.skip(ftype)
22636 
      else:
22637 
        iprot.skip(ftype)
22638 
      iprot.readFieldEnd()
22639 
    iprot.readStructEnd()
22640 
 
22641 
  def write(self, oprot):
22642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22644 
      return
22645 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22646 
    if self.ex is not None:
22647 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22648 
      self.ex.write(oprot)
22649 
      oprot.writeFieldEnd()
22650 
    oprot.writeFieldStop()
22651 
    oprot.writeStructEnd()
22652 
 
22653 
  def validate(self):
22654 
    return
22655 
 
22656 
 
22657 
  def __repr__(self):
22658 
    L = ['%s=%r' % (key, value)
22659 
      for key, value in self.__dict__.iteritems()]
22660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22661 
 
22662 
  def __eq__(self, other):
22663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22664 
 
22665 
  def __ne__(self, other):
22666 
    return not (self == other)
22667 
 
5386 phani.kuma 22668 
class getSettlementForPrepaid_args:
4600 varun.gupt 22669 
  """
22670 
  Attributes:
5189 varun.gupt 22671 
   - referenceId
22672 
   - isRefund
4600 varun.gupt 22673 
  """
22674 
 
22675 
  thrift_spec = (
22676 
    None, # 0
5189 varun.gupt 22677 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22678 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22679 
  )
22680 
 
5386 phani.kuma 22681 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22682 
    self.referenceId = referenceId
22683 
    self.isRefund = isRefund
4600 varun.gupt 22684 
 
22685 
  def read(self, iprot):
22686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22688 
      return
22689 
    iprot.readStructBegin()
22690 
    while True:
22691 
      (fname, ftype, fid) = iprot.readFieldBegin()
22692 
      if ftype == TType.STOP:
22693 
        break
22694 
      if fid == 1:
22695 
        if ftype == TType.I64:
5189 varun.gupt 22696 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22697 
        else:
22698 
          iprot.skip(ftype)
5189 varun.gupt 22699 
      elif fid == 2:
22700 
        if ftype == TType.BOOL:
22701 
          self.isRefund = iprot.readBool();
22702 
        else:
22703 
          iprot.skip(ftype)
4600 varun.gupt 22704 
      else:
22705 
        iprot.skip(ftype)
22706 
      iprot.readFieldEnd()
22707 
    iprot.readStructEnd()
22708 
 
22709 
  def write(self, oprot):
22710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22712 
      return
5386 phani.kuma 22713 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22714 
    if self.referenceId is not None:
22715 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22716 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22717 
      oprot.writeFieldEnd()
5386 phani.kuma 22718 
    if self.isRefund is not None:
22719 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22720 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22721 
      oprot.writeFieldEnd()
5386 phani.kuma 22722 
    oprot.writeFieldStop()
22723 
    oprot.writeStructEnd()
22724 
 
22725 
  def validate(self):
22726 
    return
22727 
 
22728 
 
22729 
  def __repr__(self):
22730 
    L = ['%s=%r' % (key, value)
22731 
      for key, value in self.__dict__.iteritems()]
22732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22733 
 
22734 
  def __eq__(self, other):
22735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22736 
 
22737 
  def __ne__(self, other):
22738 
    return not (self == other)
22739 
 
22740 
class getSettlementForPrepaid_result:
22741 
  """
22742 
  Attributes:
22743 
   - success
22744 
   - ex
22745 
  """
22746 
 
22747 
  thrift_spec = (
22748 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22749 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22750 
  )
22751 
 
22752 
  def __init__(self, success=None, ex=None,):
22753 
    self.success = success
22754 
    self.ex = ex
22755 
 
22756 
  def read(self, iprot):
22757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22759 
      return
22760 
    iprot.readStructBegin()
22761 
    while True:
22762 
      (fname, ftype, fid) = iprot.readFieldBegin()
22763 
      if ftype == TType.STOP:
22764 
        break
22765 
      if fid == 0:
22766 
        if ftype == TType.STRUCT:
22767 
          self.success = PaymentSettlement()
22768 
          self.success.read(iprot)
22769 
        else:
22770 
          iprot.skip(ftype)
22771 
      elif fid == 1:
22772 
        if ftype == TType.STRUCT:
22773 
          self.ex = TransactionServiceException()
22774 
          self.ex.read(iprot)
22775 
        else:
22776 
          iprot.skip(ftype)
22777 
      else:
22778 
        iprot.skip(ftype)
22779 
      iprot.readFieldEnd()
22780 
    iprot.readStructEnd()
22781 
 
22782 
  def write(self, oprot):
22783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22785 
      return
22786 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22787 
    if self.success is not None:
22788 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22789 
      self.success.write(oprot)
22790 
      oprot.writeFieldEnd()
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 
 
22813 
class getSettlementForCod_args:
22814 
  """
22815 
  Attributes:
22816 
   - orderId
22817 
   - isRefund
22818 
  """
22819 
 
22820 
  thrift_spec = (
22821 
    None, # 0
22822 
    (1, TType.I64, 'orderId', None, None, ), # 1
22823 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22824 
  )
22825 
 
22826 
  def __init__(self, orderId=None, isRefund=None,):
22827 
    self.orderId = orderId
22828 
    self.isRefund = isRefund
22829 
 
22830 
  def read(self, iprot):
22831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22833 
      return
22834 
    iprot.readStructBegin()
22835 
    while True:
22836 
      (fname, ftype, fid) = iprot.readFieldBegin()
22837 
      if ftype == TType.STOP:
22838 
        break
22839 
      if fid == 1:
22840 
        if ftype == TType.I64:
22841 
          self.orderId = iprot.readI64();
22842 
        else:
22843 
          iprot.skip(ftype)
22844 
      elif fid == 2:
22845 
        if ftype == TType.BOOL:
22846 
          self.isRefund = iprot.readBool();
22847 
        else:
22848 
          iprot.skip(ftype)
22849 
      else:
22850 
        iprot.skip(ftype)
22851 
      iprot.readFieldEnd()
22852 
    iprot.readStructEnd()
22853 
 
22854 
  def write(self, oprot):
22855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22857 
      return
22858 
    oprot.writeStructBegin('getSettlementForCod_args')
22859 
    if self.orderId is not None:
22860 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22861 
      oprot.writeI64(self.orderId)
22862 
      oprot.writeFieldEnd()
5189 varun.gupt 22863 
    if self.isRefund is not None:
5386 phani.kuma 22864 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 22865 
      oprot.writeBool(self.isRefund)
22866 
      oprot.writeFieldEnd()
4600 varun.gupt 22867 
    oprot.writeFieldStop()
22868 
    oprot.writeStructEnd()
22869 
 
22870 
  def validate(self):
22871 
    return
22872 
 
22873 
 
22874 
  def __repr__(self):
22875 
    L = ['%s=%r' % (key, value)
22876 
      for key, value in self.__dict__.iteritems()]
22877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22878 
 
22879 
  def __eq__(self, other):
22880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22881 
 
22882 
  def __ne__(self, other):
22883 
    return not (self == other)
22884 
 
5386 phani.kuma 22885 
class getSettlementForCod_result:
4600 varun.gupt 22886 
  """
22887 
  Attributes:
22888 
   - success
22889 
   - ex
22890 
  """
22891 
 
22892 
  thrift_spec = (
22893 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22895 
  )
22896 
 
22897 
  def __init__(self, success=None, ex=None,):
22898 
    self.success = success
22899 
    self.ex = ex
22900 
 
22901 
  def read(self, iprot):
22902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22904 
      return
22905 
    iprot.readStructBegin()
22906 
    while True:
22907 
      (fname, ftype, fid) = iprot.readFieldBegin()
22908 
      if ftype == TType.STOP:
22909 
        break
22910 
      if fid == 0:
22911 
        if ftype == TType.STRUCT:
22912 
          self.success = PaymentSettlement()
22913 
          self.success.read(iprot)
22914 
        else:
22915 
          iprot.skip(ftype)
22916 
      elif fid == 1:
22917 
        if ftype == TType.STRUCT:
22918 
          self.ex = TransactionServiceException()
22919 
          self.ex.read(iprot)
22920 
        else:
22921 
          iprot.skip(ftype)
22922 
      else:
22923 
        iprot.skip(ftype)
22924 
      iprot.readFieldEnd()
22925 
    iprot.readStructEnd()
22926 
 
22927 
  def write(self, oprot):
22928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22930 
      return
5386 phani.kuma 22931 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 22932 
    if self.success is not None:
22933 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22934 
      self.success.write(oprot)
22935 
      oprot.writeFieldEnd()
22936 
    if self.ex is not None:
22937 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22938 
      self.ex.write(oprot)
22939 
      oprot.writeFieldEnd()
22940 
    oprot.writeFieldStop()
22941 
    oprot.writeStructEnd()
22942 
 
22943 
  def validate(self):
22944 
    return
22945 
 
22946 
 
22947 
  def __repr__(self):
22948 
    L = ['%s=%r' % (key, value)
22949 
      for key, value in self.__dict__.iteritems()]
22950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22951 
 
22952 
  def __eq__(self, other):
22953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22954 
 
22955 
  def __ne__(self, other):
22956 
    return not (self == other)
22957 
 
22958 
class getEBSSettlementSummaries_args:
22959 
 
22960 
  thrift_spec = (
22961 
  )
22962 
 
22963 
  def read(self, iprot):
22964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22966 
      return
22967 
    iprot.readStructBegin()
22968 
    while True:
22969 
      (fname, ftype, fid) = iprot.readFieldBegin()
22970 
      if ftype == TType.STOP:
22971 
        break
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('getEBSSettlementSummaries_args')
22982 
    oprot.writeFieldStop()
22983 
    oprot.writeStructEnd()
22984 
 
22985 
  def validate(self):
22986 
    return
22987 
 
22988 
 
22989 
  def __repr__(self):
22990 
    L = ['%s=%r' % (key, value)
22991 
      for key, value in self.__dict__.iteritems()]
22992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22993 
 
22994 
  def __eq__(self, other):
22995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22996 
 
22997 
  def __ne__(self, other):
22998 
    return not (self == other)
22999 
 
23000 
class getEBSSettlementSummaries_result:
23001 
  """
23002 
  Attributes:
23003 
   - success
23004 
   - ex
23005 
  """
23006 
 
23007 
  thrift_spec = (
23008 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23010 
  )
23011 
 
23012 
  def __init__(self, success=None, ex=None,):
23013 
    self.success = success
23014 
    self.ex = ex
23015 
 
23016 
  def read(self, iprot):
23017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23019 
      return
23020 
    iprot.readStructBegin()
23021 
    while True:
23022 
      (fname, ftype, fid) = iprot.readFieldBegin()
23023 
      if ftype == TType.STOP:
23024 
        break
23025 
      if fid == 0:
23026 
        if ftype == TType.MAP:
23027 
          self.success = {}
6031 rajveer 23028 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
23029 
          for _i515 in xrange(_size511):
23030 
            _key516 = iprot.readI64();
23031 
            _val517 = iprot.readString();
23032 
            self.success[_key516] = _val517
4600 varun.gupt 23033 
          iprot.readMapEnd()
23034 
        else:
23035 
          iprot.skip(ftype)
23036 
      elif fid == 1:
23037 
        if ftype == TType.STRUCT:
23038 
          self.ex = TransactionServiceException()
23039 
          self.ex.read(iprot)
23040 
        else:
23041 
          iprot.skip(ftype)
23042 
      else:
23043 
        iprot.skip(ftype)
23044 
      iprot.readFieldEnd()
23045 
    iprot.readStructEnd()
23046 
 
23047 
  def write(self, oprot):
23048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23050 
      return
23051 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23052 
    if self.success is not None:
23053 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23054 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6031 rajveer 23055 
      for kiter518,viter519 in self.success.items():
23056 
        oprot.writeI64(kiter518)
23057 
        oprot.writeString(viter519)
4600 varun.gupt 23058 
      oprot.writeMapEnd()
23059 
      oprot.writeFieldEnd()
23060 
    if self.ex is not None:
23061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23062 
      self.ex.write(oprot)
23063 
      oprot.writeFieldEnd()
23064 
    oprot.writeFieldStop()
23065 
    oprot.writeStructEnd()
23066 
 
23067 
  def validate(self):
23068 
    return
23069 
 
23070 
 
23071 
  def __repr__(self):
23072 
    L = ['%s=%r' % (key, value)
23073 
      for key, value in self.__dict__.iteritems()]
23074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23075 
 
23076 
  def __eq__(self, other):
23077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23078 
 
23079 
  def __ne__(self, other):
23080 
    return not (self == other)
23081 
 
23082 
class markEBSSettlementUploaded_args:
23083 
  """
23084 
  Attributes:
23085 
   - settlementId
23086 
  """
23087 
 
23088 
  thrift_spec = (
23089 
    None, # 0
23090 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23091 
  )
23092 
 
23093 
  def __init__(self, settlementId=None,):
23094 
    self.settlementId = settlementId
23095 
 
23096 
  def read(self, iprot):
23097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23099 
      return
23100 
    iprot.readStructBegin()
23101 
    while True:
23102 
      (fname, ftype, fid) = iprot.readFieldBegin()
23103 
      if ftype == TType.STOP:
23104 
        break
23105 
      if fid == 1:
23106 
        if ftype == TType.I64:
23107 
          self.settlementId = iprot.readI64();
23108 
        else:
23109 
          iprot.skip(ftype)
23110 
      else:
23111 
        iprot.skip(ftype)
23112 
      iprot.readFieldEnd()
23113 
    iprot.readStructEnd()
23114 
 
23115 
  def write(self, oprot):
23116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23118 
      return
23119 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23120 
    if self.settlementId is not None:
23121 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23122 
      oprot.writeI64(self.settlementId)
23123 
      oprot.writeFieldEnd()
23124 
    oprot.writeFieldStop()
23125 
    oprot.writeStructEnd()
23126 
 
23127 
  def validate(self):
23128 
    return
23129 
 
23130 
 
23131 
  def __repr__(self):
23132 
    L = ['%s=%r' % (key, value)
23133 
      for key, value in self.__dict__.iteritems()]
23134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23135 
 
23136 
  def __eq__(self, other):
23137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23138 
 
23139 
  def __ne__(self, other):
23140 
    return not (self == other)
23141 
 
23142 
class markEBSSettlementUploaded_result:
23143 
  """
23144 
  Attributes:
23145 
   - ex
23146 
  """
23147 
 
23148 
  thrift_spec = (
23149 
    None, # 0
23150 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23151 
  )
23152 
 
23153 
  def __init__(self, ex=None,):
23154 
    self.ex = ex
23155 
 
23156 
  def read(self, iprot):
23157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23159 
      return
23160 
    iprot.readStructBegin()
23161 
    while True:
23162 
      (fname, ftype, fid) = iprot.readFieldBegin()
23163 
      if ftype == TType.STOP:
23164 
        break
23165 
      if fid == 1:
23166 
        if ftype == TType.STRUCT:
23167 
          self.ex = TransactionServiceException()
23168 
          self.ex.read(iprot)
23169 
        else:
23170 
          iprot.skip(ftype)
23171 
      else:
23172 
        iprot.skip(ftype)
23173 
      iprot.readFieldEnd()
23174 
    iprot.readStructEnd()
23175 
 
23176 
  def write(self, oprot):
23177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23179 
      return
23180 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23181 
    if self.ex is not None:
23182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23183 
      self.ex.write(oprot)
23184 
      oprot.writeFieldEnd()
23185 
    oprot.writeFieldStop()
23186 
    oprot.writeStructEnd()
23187 
 
23188 
  def validate(self):
23189 
    return
23190 
 
23191 
 
23192 
  def __repr__(self):
23193 
    L = ['%s=%r' % (key, value)
23194 
      for key, value in self.__dict__.iteritems()]
23195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23196 
 
23197 
  def __eq__(self, other):
23198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23199 
 
23200 
  def __ne__(self, other):
23201 
    return not (self == other)
23202 
 
23203 
class getEBSSettlementDate_args:
23204 
  """
23205 
  Attributes:
23206 
   - settlementId
23207 
  """
23208 
 
23209 
  thrift_spec = (
23210 
    None, # 0
23211 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23212 
  )
23213 
 
23214 
  def __init__(self, settlementId=None,):
23215 
    self.settlementId = settlementId
23216 
 
23217 
  def read(self, iprot):
23218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23220 
      return
23221 
    iprot.readStructBegin()
23222 
    while True:
23223 
      (fname, ftype, fid) = iprot.readFieldBegin()
23224 
      if ftype == TType.STOP:
23225 
        break
23226 
      if fid == 1:
23227 
        if ftype == TType.I64:
23228 
          self.settlementId = iprot.readI64();
23229 
        else:
23230 
          iprot.skip(ftype)
23231 
      else:
23232 
        iprot.skip(ftype)
23233 
      iprot.readFieldEnd()
23234 
    iprot.readStructEnd()
23235 
 
23236 
  def write(self, oprot):
23237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23239 
      return
23240 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23241 
    if self.settlementId is not None:
23242 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23243 
      oprot.writeI64(self.settlementId)
23244 
      oprot.writeFieldEnd()
23245 
    oprot.writeFieldStop()
23246 
    oprot.writeStructEnd()
23247 
 
23248 
  def validate(self):
23249 
    return
23250 
 
23251 
 
23252 
  def __repr__(self):
23253 
    L = ['%s=%r' % (key, value)
23254 
      for key, value in self.__dict__.iteritems()]
23255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23256 
 
23257 
  def __eq__(self, other):
23258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23259 
 
23260 
  def __ne__(self, other):
23261 
    return not (self == other)
23262 
 
23263 
class getEBSSettlementDate_result:
23264 
  """
23265 
  Attributes:
23266 
   - success
23267 
   - ex
23268 
  """
23269 
 
23270 
  thrift_spec = (
23271 
    (0, TType.I64, 'success', None, None, ), # 0
23272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23273 
  )
23274 
 
23275 
  def __init__(self, success=None, ex=None,):
23276 
    self.success = success
23277 
    self.ex = ex
23278 
 
23279 
  def read(self, iprot):
23280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23282 
      return
23283 
    iprot.readStructBegin()
23284 
    while True:
23285 
      (fname, ftype, fid) = iprot.readFieldBegin()
23286 
      if ftype == TType.STOP:
23287 
        break
23288 
      if fid == 0:
23289 
        if ftype == TType.I64:
23290 
          self.success = iprot.readI64();
23291 
        else:
23292 
          iprot.skip(ftype)
23293 
      elif fid == 1:
23294 
        if ftype == TType.STRUCT:
23295 
          self.ex = TransactionServiceException()
23296 
          self.ex.read(iprot)
23297 
        else:
23298 
          iprot.skip(ftype)
23299 
      else:
23300 
        iprot.skip(ftype)
23301 
      iprot.readFieldEnd()
23302 
    iprot.readStructEnd()
23303 
 
23304 
  def write(self, oprot):
23305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23307 
      return
23308 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23309 
    if self.success is not None:
23310 
      oprot.writeFieldBegin('success', TType.I64, 0)
23311 
      oprot.writeI64(self.success)
23312 
      oprot.writeFieldEnd()
23313 
    if self.ex is not None:
23314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23315 
      self.ex.write(oprot)
23316 
      oprot.writeFieldEnd()
23317 
    oprot.writeFieldStop()
23318 
    oprot.writeStructEnd()
23319 
 
23320 
  def validate(self):
23321 
    return
23322 
 
23323 
 
23324 
  def __repr__(self):
23325 
    L = ['%s=%r' % (key, value)
23326 
      for key, value in self.__dict__.iteritems()]
23327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23328 
 
23329 
  def __eq__(self, other):
23330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23331 
 
23332 
  def __ne__(self, other):
23333 
    return not (self == other)
4715 varun.gupt 23334 
 
23335 
class getSettlementsByDate_args:
23336 
  """
23337 
  Attributes:
23338 
   - settlementDateFrom
23339 
   - settlementDateTo
23340 
   - isRefund
23341 
  """
23342 
 
23343 
  thrift_spec = (
23344 
    None, # 0
23345 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23346 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23347 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23348 
  )
23349 
 
23350 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23351 
    self.settlementDateFrom = settlementDateFrom
23352 
    self.settlementDateTo = settlementDateTo
23353 
    self.isRefund = isRefund
23354 
 
23355 
  def read(self, iprot):
23356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23358 
      return
23359 
    iprot.readStructBegin()
23360 
    while True:
23361 
      (fname, ftype, fid) = iprot.readFieldBegin()
23362 
      if ftype == TType.STOP:
23363 
        break
23364 
      if fid == 1:
23365 
        if ftype == TType.I64:
23366 
          self.settlementDateFrom = iprot.readI64();
23367 
        else:
23368 
          iprot.skip(ftype)
23369 
      elif fid == 2:
23370 
        if ftype == TType.I64:
23371 
          self.settlementDateTo = iprot.readI64();
23372 
        else:
23373 
          iprot.skip(ftype)
23374 
      elif fid == 3:
23375 
        if ftype == TType.BOOL:
23376 
          self.isRefund = iprot.readBool();
23377 
        else:
23378 
          iprot.skip(ftype)
23379 
      else:
23380 
        iprot.skip(ftype)
23381 
      iprot.readFieldEnd()
23382 
    iprot.readStructEnd()
23383 
 
23384 
  def write(self, oprot):
23385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23387 
      return
23388 
    oprot.writeStructBegin('getSettlementsByDate_args')
23389 
    if self.settlementDateFrom is not None:
23390 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23391 
      oprot.writeI64(self.settlementDateFrom)
23392 
      oprot.writeFieldEnd()
23393 
    if self.settlementDateTo is not None:
23394 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23395 
      oprot.writeI64(self.settlementDateTo)
23396 
      oprot.writeFieldEnd()
23397 
    if self.isRefund is not None:
23398 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23399 
      oprot.writeBool(self.isRefund)
23400 
      oprot.writeFieldEnd()
23401 
    oprot.writeFieldStop()
23402 
    oprot.writeStructEnd()
23403 
 
23404 
  def validate(self):
23405 
    return
23406 
 
23407 
 
23408 
  def __repr__(self):
23409 
    L = ['%s=%r' % (key, value)
23410 
      for key, value in self.__dict__.iteritems()]
23411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23412 
 
23413 
  def __eq__(self, other):
23414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23415 
 
23416 
  def __ne__(self, other):
23417 
    return not (self == other)
23418 
 
23419 
class getSettlementsByDate_result:
23420 
  """
23421 
  Attributes:
23422 
   - success
23423 
   - ex
23424 
  """
23425 
 
23426 
  thrift_spec = (
23427 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23428 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23429 
  )
23430 
 
23431 
  def __init__(self, success=None, ex=None,):
23432 
    self.success = success
23433 
    self.ex = ex
23434 
 
23435 
  def read(self, iprot):
23436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23438 
      return
23439 
    iprot.readStructBegin()
23440 
    while True:
23441 
      (fname, ftype, fid) = iprot.readFieldBegin()
23442 
      if ftype == TType.STOP:
23443 
        break
23444 
      if fid == 0:
23445 
        if ftype == TType.LIST:
23446 
          self.success = []
6031 rajveer 23447 
          (_etype523, _size520) = iprot.readListBegin()
23448 
          for _i524 in xrange(_size520):
23449 
            _elem525 = PaymentSettlement()
23450 
            _elem525.read(iprot)
23451 
            self.success.append(_elem525)
4715 varun.gupt 23452 
          iprot.readListEnd()
23453 
        else:
23454 
          iprot.skip(ftype)
23455 
      elif fid == 1:
23456 
        if ftype == TType.STRUCT:
23457 
          self.ex = TransactionServiceException()
23458 
          self.ex.read(iprot)
23459 
        else:
23460 
          iprot.skip(ftype)
23461 
      else:
23462 
        iprot.skip(ftype)
23463 
      iprot.readFieldEnd()
23464 
    iprot.readStructEnd()
23465 
 
23466 
  def write(self, oprot):
23467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23469 
      return
23470 
    oprot.writeStructBegin('getSettlementsByDate_result')
23471 
    if self.success is not None:
23472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23474 
      for iter526 in self.success:
23475 
        iter526.write(oprot)
4715 varun.gupt 23476 
      oprot.writeListEnd()
23477 
      oprot.writeFieldEnd()
23478 
    if self.ex is not None:
23479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23480 
      self.ex.write(oprot)
23481 
      oprot.writeFieldEnd()
23482 
    oprot.writeFieldStop()
23483 
    oprot.writeStructEnd()
23484 
 
23485 
  def validate(self):
23486 
    return
23487 
 
23488 
 
23489 
  def __repr__(self):
23490 
    L = ['%s=%r' % (key, value)
23491 
      for key, value in self.__dict__.iteritems()]
23492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23493 
 
23494 
  def __eq__(self, other):
23495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23496 
 
23497 
  def __ne__(self, other):
23498 
    return not (self == other)
23499 
 
23500 
class getReshippedOrderIds_args:
23501 
  """
23502 
  Attributes:
23503 
   - orderIds
23504 
  """
23505 
 
23506 
  thrift_spec = (
23507 
    None, # 0
23508 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23509 
  )
23510 
 
23511 
  def __init__(self, orderIds=None,):
23512 
    self.orderIds = orderIds
23513 
 
23514 
  def read(self, iprot):
23515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23517 
      return
23518 
    iprot.readStructBegin()
23519 
    while True:
23520 
      (fname, ftype, fid) = iprot.readFieldBegin()
23521 
      if ftype == TType.STOP:
23522 
        break
23523 
      if fid == 1:
23524 
        if ftype == TType.LIST:
23525 
          self.orderIds = []
6031 rajveer 23526 
          (_etype530, _size527) = iprot.readListBegin()
23527 
          for _i531 in xrange(_size527):
23528 
            _elem532 = iprot.readI64();
23529 
            self.orderIds.append(_elem532)
4715 varun.gupt 23530 
          iprot.readListEnd()
23531 
        else:
23532 
          iprot.skip(ftype)
23533 
      else:
23534 
        iprot.skip(ftype)
23535 
      iprot.readFieldEnd()
23536 
    iprot.readStructEnd()
23537 
 
23538 
  def write(self, oprot):
23539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23541 
      return
23542 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23543 
    if self.orderIds is not None:
23544 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23545 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 23546 
      for iter533 in self.orderIds:
23547 
        oprot.writeI64(iter533)
4715 varun.gupt 23548 
      oprot.writeListEnd()
23549 
      oprot.writeFieldEnd()
23550 
    oprot.writeFieldStop()
23551 
    oprot.writeStructEnd()
23552 
 
23553 
  def validate(self):
23554 
    return
23555 
 
23556 
 
23557 
  def __repr__(self):
23558 
    L = ['%s=%r' % (key, value)
23559 
      for key, value in self.__dict__.iteritems()]
23560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23561 
 
23562 
  def __eq__(self, other):
23563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23564 
 
23565 
  def __ne__(self, other):
23566 
    return not (self == other)
23567 
 
23568 
class getReshippedOrderIds_result:
23569 
  """
23570 
  Attributes:
23571 
   - success
23572 
   - ex
23573 
  """
23574 
 
23575 
  thrift_spec = (
23576 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23577 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23578 
  )
23579 
 
23580 
  def __init__(self, success=None, ex=None,):
23581 
    self.success = success
23582 
    self.ex = ex
23583 
 
23584 
  def read(self, iprot):
23585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23587 
      return
23588 
    iprot.readStructBegin()
23589 
    while True:
23590 
      (fname, ftype, fid) = iprot.readFieldBegin()
23591 
      if ftype == TType.STOP:
23592 
        break
23593 
      if fid == 0:
23594 
        if ftype == TType.LIST:
23595 
          self.success = []
6031 rajveer 23596 
          (_etype537, _size534) = iprot.readListBegin()
23597 
          for _i538 in xrange(_size534):
23598 
            _elem539 = iprot.readI64();
23599 
            self.success.append(_elem539)
4715 varun.gupt 23600 
          iprot.readListEnd()
23601 
        else:
23602 
          iprot.skip(ftype)
23603 
      elif fid == 1:
23604 
        if ftype == TType.STRUCT:
23605 
          self.ex = TransactionServiceException()
23606 
          self.ex.read(iprot)
23607 
        else:
23608 
          iprot.skip(ftype)
23609 
      else:
23610 
        iprot.skip(ftype)
23611 
      iprot.readFieldEnd()
23612 
    iprot.readStructEnd()
23613 
 
23614 
  def write(self, oprot):
23615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23617 
      return
23618 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23619 
    if self.success is not None:
23620 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23621 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 23622 
      for iter540 in self.success:
23623 
        oprot.writeI64(iter540)
4715 varun.gupt 23624 
      oprot.writeListEnd()
23625 
      oprot.writeFieldEnd()
23626 
    if self.ex is not None:
23627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23628 
      self.ex.write(oprot)
23629 
      oprot.writeFieldEnd()
23630 
    oprot.writeFieldStop()
23631 
    oprot.writeStructEnd()
23632 
 
23633 
  def validate(self):
23634 
    return
23635 
 
23636 
 
23637 
  def __repr__(self):
23638 
    L = ['%s=%r' % (key, value)
23639 
      for key, value in self.__dict__.iteritems()]
23640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23641 
 
23642 
  def __eq__(self, other):
23643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23644 
 
23645 
  def __ne__(self, other):
23646 
    return not (self == other)
4757 mandeep.dh 23647 
 
5481 phani.kuma 23648 
class getBilledOrders_args:
4875 varun.gupt 23649 
  """
23650 
  Attributes:
23651 
   - vendorId
5481 phani.kuma 23652 
   - onlyVendorNotPaid
23653 
   - billingDateFrom
23654 
   - billingDateTo
4875 varun.gupt 23655 
  """
23656 
 
23657 
  thrift_spec = (
23658 
    None, # 0
23659 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23660 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23661 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23662 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23663 
  )
23664 
 
5481 phani.kuma 23665 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23666 
    self.vendorId = vendorId
5481 phani.kuma 23667 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23668 
    self.billingDateFrom = billingDateFrom
23669 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23670 
 
23671 
  def read(self, iprot):
23672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23674 
      return
23675 
    iprot.readStructBegin()
23676 
    while True:
23677 
      (fname, ftype, fid) = iprot.readFieldBegin()
23678 
      if ftype == TType.STOP:
23679 
        break
23680 
      if fid == 1:
23681 
        if ftype == TType.I64:
23682 
          self.vendorId = iprot.readI64();
23683 
        else:
23684 
          iprot.skip(ftype)
5481 phani.kuma 23685 
      elif fid == 2:
23686 
        if ftype == TType.BOOL:
23687 
          self.onlyVendorNotPaid = iprot.readBool();
23688 
        else:
23689 
          iprot.skip(ftype)
23690 
      elif fid == 3:
23691 
        if ftype == TType.I64:
23692 
          self.billingDateFrom = iprot.readI64();
23693 
        else:
23694 
          iprot.skip(ftype)
23695 
      elif fid == 4:
23696 
        if ftype == TType.I64:
23697 
          self.billingDateTo = iprot.readI64();
23698 
        else:
23699 
          iprot.skip(ftype)
4875 varun.gupt 23700 
      else:
23701 
        iprot.skip(ftype)
23702 
      iprot.readFieldEnd()
23703 
    iprot.readStructEnd()
23704 
 
23705 
  def write(self, oprot):
23706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23708 
      return
5481 phani.kuma 23709 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23710 
    if self.vendorId is not None:
23711 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23712 
      oprot.writeI64(self.vendorId)
23713 
      oprot.writeFieldEnd()
5481 phani.kuma 23714 
    if self.onlyVendorNotPaid is not None:
23715 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23716 
      oprot.writeBool(self.onlyVendorNotPaid)
23717 
      oprot.writeFieldEnd()
23718 
    if self.billingDateFrom is not None:
23719 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23720 
      oprot.writeI64(self.billingDateFrom)
23721 
      oprot.writeFieldEnd()
23722 
    if self.billingDateTo is not None:
23723 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23724 
      oprot.writeI64(self.billingDateTo)
23725 
      oprot.writeFieldEnd()
4875 varun.gupt 23726 
    oprot.writeFieldStop()
23727 
    oprot.writeStructEnd()
23728 
 
23729 
  def validate(self):
23730 
    return
23731 
 
23732 
 
23733 
  def __repr__(self):
23734 
    L = ['%s=%r' % (key, value)
23735 
      for key, value in self.__dict__.iteritems()]
23736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23737 
 
23738 
  def __eq__(self, other):
23739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23740 
 
23741 
  def __ne__(self, other):
23742 
    return not (self == other)
23743 
 
5481 phani.kuma 23744 
class getBilledOrders_result:
4875 varun.gupt 23745 
  """
23746 
  Attributes:
23747 
   - success
23748 
   - ex
23749 
  """
23750 
 
23751 
  thrift_spec = (
23752 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23753 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23754 
  )
23755 
 
23756 
  def __init__(self, success=None, ex=None,):
23757 
    self.success = success
23758 
    self.ex = ex
23759 
 
23760 
  def read(self, iprot):
23761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23763 
      return
23764 
    iprot.readStructBegin()
23765 
    while True:
23766 
      (fname, ftype, fid) = iprot.readFieldBegin()
23767 
      if ftype == TType.STOP:
23768 
        break
23769 
      if fid == 0:
23770 
        if ftype == TType.LIST:
23771 
          self.success = []
6031 rajveer 23772 
          (_etype544, _size541) = iprot.readListBegin()
23773 
          for _i545 in xrange(_size541):
23774 
            _elem546 = Order()
23775 
            _elem546.read(iprot)
23776 
            self.success.append(_elem546)
4875 varun.gupt 23777 
          iprot.readListEnd()
23778 
        else:
23779 
          iprot.skip(ftype)
23780 
      elif fid == 1:
23781 
        if ftype == TType.STRUCT:
23782 
          self.ex = TransactionServiceException()
23783 
          self.ex.read(iprot)
23784 
        else:
23785 
          iprot.skip(ftype)
23786 
      else:
23787 
        iprot.skip(ftype)
23788 
      iprot.readFieldEnd()
23789 
    iprot.readStructEnd()
23790 
 
23791 
  def write(self, oprot):
23792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23794 
      return
5481 phani.kuma 23795 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23796 
    if self.success is not None:
23797 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23798 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23799 
      for iter547 in self.success:
23800 
        iter547.write(oprot)
4875 varun.gupt 23801 
      oprot.writeListEnd()
23802 
      oprot.writeFieldEnd()
23803 
    if self.ex is not None:
23804 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23805 
      self.ex.write(oprot)
23806 
      oprot.writeFieldEnd()
23807 
    oprot.writeFieldStop()
23808 
    oprot.writeStructEnd()
23809 
 
23810 
  def validate(self):
23811 
    return
23812 
 
23813 
 
23814 
  def __repr__(self):
23815 
    L = ['%s=%r' % (key, value)
23816 
      for key, value in self.__dict__.iteritems()]
23817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23818 
 
23819 
  def __eq__(self, other):
23820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23821 
 
23822 
  def __ne__(self, other):
23823 
    return not (self == other)
5031 varun.gupt 23824 
 
23825 
class getStatusDistributionOfOrders_args:
23826 
  """
23827 
  Attributes:
23828 
   - startDate
23829 
   - endDate
23830 
  """
23831 
 
23832 
  thrift_spec = (
23833 
    None, # 0
23834 
    (1, TType.I64, 'startDate', None, None, ), # 1
23835 
    (2, TType.I64, 'endDate', None, None, ), # 2
23836 
  )
23837 
 
23838 
  def __init__(self, startDate=None, endDate=None,):
23839 
    self.startDate = startDate
23840 
    self.endDate = endDate
23841 
 
23842 
  def read(self, iprot):
23843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23845 
      return
23846 
    iprot.readStructBegin()
23847 
    while True:
23848 
      (fname, ftype, fid) = iprot.readFieldBegin()
23849 
      if ftype == TType.STOP:
23850 
        break
23851 
      if fid == 1:
23852 
        if ftype == TType.I64:
23853 
          self.startDate = iprot.readI64();
23854 
        else:
23855 
          iprot.skip(ftype)
23856 
      elif fid == 2:
23857 
        if ftype == TType.I64:
23858 
          self.endDate = iprot.readI64();
23859 
        else:
23860 
          iprot.skip(ftype)
23861 
      else:
23862 
        iprot.skip(ftype)
23863 
      iprot.readFieldEnd()
23864 
    iprot.readStructEnd()
23865 
 
23866 
  def write(self, oprot):
23867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23869 
      return
23870 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
23871 
    if self.startDate is not None:
23872 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
23873 
      oprot.writeI64(self.startDate)
23874 
      oprot.writeFieldEnd()
23875 
    if self.endDate is not None:
23876 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
23877 
      oprot.writeI64(self.endDate)
23878 
      oprot.writeFieldEnd()
23879 
    oprot.writeFieldStop()
23880 
    oprot.writeStructEnd()
23881 
 
23882 
  def validate(self):
23883 
    return
23884 
 
23885 
 
23886 
  def __repr__(self):
23887 
    L = ['%s=%r' % (key, value)
23888 
      for key, value in self.__dict__.iteritems()]
23889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23890 
 
23891 
  def __eq__(self, other):
23892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23893 
 
23894 
  def __ne__(self, other):
23895 
    return not (self == other)
23896 
 
23897 
class getStatusDistributionOfOrders_result:
23898 
  """
23899 
  Attributes:
23900 
   - success
23901 
   - ex
23902 
  """
23903 
 
23904 
  thrift_spec = (
23905 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
23906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23907 
  )
23908 
 
23909 
  def __init__(self, success=None, ex=None,):
23910 
    self.success = success
23911 
    self.ex = ex
23912 
 
23913 
  def read(self, iprot):
23914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23916 
      return
23917 
    iprot.readStructBegin()
23918 
    while True:
23919 
      (fname, ftype, fid) = iprot.readFieldBegin()
23920 
      if ftype == TType.STOP:
23921 
        break
23922 
      if fid == 0:
23923 
        if ftype == TType.MAP:
23924 
          self.success = {}
6031 rajveer 23925 
          (_ktype549, _vtype550, _size548 ) = iprot.readMapBegin()
23926 
          for _i552 in xrange(_size548):
23927 
            _key553 = iprot.readI64();
23928 
            _val554 = iprot.readI64();
23929 
            self.success[_key553] = _val554
5031 varun.gupt 23930 
          iprot.readMapEnd()
23931 
        else:
23932 
          iprot.skip(ftype)
23933 
      elif fid == 1:
23934 
        if ftype == TType.STRUCT:
23935 
          self.ex = TransactionServiceException()
23936 
          self.ex.read(iprot)
23937 
        else:
23938 
          iprot.skip(ftype)
23939 
      else:
23940 
        iprot.skip(ftype)
23941 
      iprot.readFieldEnd()
23942 
    iprot.readStructEnd()
23943 
 
23944 
  def write(self, oprot):
23945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23947 
      return
23948 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
23949 
    if self.success is not None:
23950 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23951 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 23952 
      for kiter555,viter556 in self.success.items():
23953 
        oprot.writeI64(kiter555)
23954 
        oprot.writeI64(viter556)
5031 varun.gupt 23955 
      oprot.writeMapEnd()
23956 
      oprot.writeFieldEnd()
23957 
    if self.ex is not None:
23958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23959 
      self.ex.write(oprot)
23960 
      oprot.writeFieldEnd()
23961 
    oprot.writeFieldStop()
23962 
    oprot.writeStructEnd()
23963 
 
23964 
  def validate(self):
23965 
    return
23966 
 
23967 
 
23968 
  def __repr__(self):
23969 
    L = ['%s=%r' % (key, value)
23970 
      for key, value in self.__dict__.iteritems()]
23971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23972 
 
23973 
  def __eq__(self, other):
23974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23975 
 
23976 
  def __ne__(self, other):
23977 
    return not (self == other)
5067 varun.gupt 23978 
 
23979 
class getOrderIdsForStatus_args:
23980 
  """
23981 
  Attributes:
23982 
   - status
23983 
   - startDatetime
23984 
   - endDatetime
23985 
  """
23986 
 
23987 
  thrift_spec = (
23988 
    None, # 0
23989 
    (1, TType.I64, 'status', None, None, ), # 1
23990 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23991 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23992 
  )
23993 
 
23994 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23995 
    self.status = status
23996 
    self.startDatetime = startDatetime
23997 
    self.endDatetime = endDatetime
23998 
 
23999 
  def read(self, iprot):
24000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24002 
      return
24003 
    iprot.readStructBegin()
24004 
    while True:
24005 
      (fname, ftype, fid) = iprot.readFieldBegin()
24006 
      if ftype == TType.STOP:
24007 
        break
24008 
      if fid == 1:
24009 
        if ftype == TType.I64:
24010 
          self.status = iprot.readI64();
24011 
        else:
24012 
          iprot.skip(ftype)
24013 
      elif fid == 2:
24014 
        if ftype == TType.I64:
24015 
          self.startDatetime = iprot.readI64();
24016 
        else:
24017 
          iprot.skip(ftype)
24018 
      elif fid == 3:
24019 
        if ftype == TType.I64:
24020 
          self.endDatetime = iprot.readI64();
24021 
        else:
24022 
          iprot.skip(ftype)
24023 
      else:
24024 
        iprot.skip(ftype)
24025 
      iprot.readFieldEnd()
24026 
    iprot.readStructEnd()
24027 
 
24028 
  def write(self, oprot):
24029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24031 
      return
24032 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24033 
    if self.status is not None:
24034 
      oprot.writeFieldBegin('status', TType.I64, 1)
24035 
      oprot.writeI64(self.status)
24036 
      oprot.writeFieldEnd()
24037 
    if self.startDatetime is not None:
24038 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24039 
      oprot.writeI64(self.startDatetime)
24040 
      oprot.writeFieldEnd()
24041 
    if self.endDatetime is not None:
24042 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24043 
      oprot.writeI64(self.endDatetime)
24044 
      oprot.writeFieldEnd()
24045 
    oprot.writeFieldStop()
24046 
    oprot.writeStructEnd()
24047 
 
24048 
  def validate(self):
24049 
    return
24050 
 
24051 
 
24052 
  def __repr__(self):
24053 
    L = ['%s=%r' % (key, value)
24054 
      for key, value in self.__dict__.iteritems()]
24055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24056 
 
24057 
  def __eq__(self, other):
24058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24059 
 
24060 
  def __ne__(self, other):
24061 
    return not (self == other)
24062 
 
24063 
class getOrderIdsForStatus_result:
24064 
  """
24065 
  Attributes:
24066 
   - success
24067 
   - ex
24068 
  """
24069 
 
24070 
  thrift_spec = (
24071 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24073 
  )
24074 
 
24075 
  def __init__(self, success=None, ex=None,):
24076 
    self.success = success
24077 
    self.ex = ex
24078 
 
24079 
  def read(self, iprot):
24080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24082 
      return
24083 
    iprot.readStructBegin()
24084 
    while True:
24085 
      (fname, ftype, fid) = iprot.readFieldBegin()
24086 
      if ftype == TType.STOP:
24087 
        break
24088 
      if fid == 0:
24089 
        if ftype == TType.LIST:
24090 
          self.success = []
6031 rajveer 24091 
          (_etype560, _size557) = iprot.readListBegin()
24092 
          for _i561 in xrange(_size557):
24093 
            _elem562 = iprot.readI64();
24094 
            self.success.append(_elem562)
5067 varun.gupt 24095 
          iprot.readListEnd()
24096 
        else:
24097 
          iprot.skip(ftype)
24098 
      elif fid == 1:
24099 
        if ftype == TType.STRUCT:
24100 
          self.ex = TransactionServiceException()
24101 
          self.ex.read(iprot)
24102 
        else:
24103 
          iprot.skip(ftype)
24104 
      else:
24105 
        iprot.skip(ftype)
24106 
      iprot.readFieldEnd()
24107 
    iprot.readStructEnd()
24108 
 
24109 
  def write(self, oprot):
24110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24112 
      return
24113 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24114 
    if self.success is not None:
24115 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24116 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 24117 
      for iter563 in self.success:
24118 
        oprot.writeI64(iter563)
5067 varun.gupt 24119 
      oprot.writeListEnd()
24120 
      oprot.writeFieldEnd()
24121 
    if self.ex is not None:
24122 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24123 
      self.ex.write(oprot)
24124 
      oprot.writeFieldEnd()
24125 
    oprot.writeFieldStop()
24126 
    oprot.writeStructEnd()
24127 
 
24128 
  def validate(self):
24129 
    return
24130 
 
24131 
 
24132 
  def __repr__(self):
24133 
    L = ['%s=%r' % (key, value)
24134 
      for key, value in self.__dict__.iteritems()]
24135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24136 
 
24137 
  def __eq__(self, other):
24138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24139 
 
24140 
  def __ne__(self, other):
24141 
    return not (self == other)
5099 varun.gupt 24142 
 
5348 anupam.sin 24143 
class updateCODAgent_args:
24144 
  """
24145 
  Attributes:
24146 
   - agent
24147 
   - orderId
24148 
  """
24149 
 
24150 
  thrift_spec = (
24151 
    None, # 0
24152 
    (1, TType.STRING, 'agent', None, None, ), # 1
24153 
    (2, TType.I64, 'orderId', None, None, ), # 2
24154 
  )
24155 
 
24156 
  def __init__(self, agent=None, orderId=None,):
24157 
    self.agent = agent
24158 
    self.orderId = orderId
24159 
 
24160 
  def read(self, iprot):
24161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24163 
      return
24164 
    iprot.readStructBegin()
24165 
    while True:
24166 
      (fname, ftype, fid) = iprot.readFieldBegin()
24167 
      if ftype == TType.STOP:
24168 
        break
24169 
      if fid == 1:
24170 
        if ftype == TType.STRING:
24171 
          self.agent = iprot.readString();
24172 
        else:
24173 
          iprot.skip(ftype)
24174 
      elif fid == 2:
24175 
        if ftype == TType.I64:
24176 
          self.orderId = iprot.readI64();
24177 
        else:
24178 
          iprot.skip(ftype)
24179 
      else:
24180 
        iprot.skip(ftype)
24181 
      iprot.readFieldEnd()
24182 
    iprot.readStructEnd()
24183 
 
24184 
  def write(self, oprot):
24185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24187 
      return
24188 
    oprot.writeStructBegin('updateCODAgent_args')
24189 
    if self.agent is not None:
24190 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24191 
      oprot.writeString(self.agent)
24192 
      oprot.writeFieldEnd()
24193 
    if self.orderId is not None:
24194 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24195 
      oprot.writeI64(self.orderId)
24196 
      oprot.writeFieldEnd()
24197 
    oprot.writeFieldStop()
24198 
    oprot.writeStructEnd()
24199 
 
24200 
  def validate(self):
24201 
    return
24202 
 
24203 
 
24204 
  def __repr__(self):
24205 
    L = ['%s=%r' % (key, value)
24206 
      for key, value in self.__dict__.iteritems()]
24207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24208 
 
24209 
  def __eq__(self, other):
24210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24211 
 
24212 
  def __ne__(self, other):
24213 
    return not (self == other)
24214 
 
24215 
class updateCODAgent_result:
24216 
  """
24217 
  Attributes:
24218 
   - ex
24219 
  """
24220 
 
24221 
  thrift_spec = (
24222 
    None, # 0
24223 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24224 
  )
24225 
 
24226 
  def __init__(self, ex=None,):
24227 
    self.ex = ex
24228 
 
24229 
  def read(self, iprot):
24230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24232 
      return
24233 
    iprot.readStructBegin()
24234 
    while True:
24235 
      (fname, ftype, fid) = iprot.readFieldBegin()
24236 
      if ftype == TType.STOP:
24237 
        break
24238 
      if fid == 1:
24239 
        if ftype == TType.STRUCT:
24240 
          self.ex = TransactionServiceException()
24241 
          self.ex.read(iprot)
24242 
        else:
24243 
          iprot.skip(ftype)
24244 
      else:
24245 
        iprot.skip(ftype)
24246 
      iprot.readFieldEnd()
24247 
    iprot.readStructEnd()
24248 
 
24249 
  def write(self, oprot):
24250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24252 
      return
24253 
    oprot.writeStructBegin('updateCODAgent_result')
24254 
    if self.ex is not None:
24255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24256 
      self.ex.write(oprot)
24257 
      oprot.writeFieldEnd()
24258 
    oprot.writeFieldStop()
24259 
    oprot.writeStructEnd()
24260 
 
24261 
  def validate(self):
24262 
    return
24263 
 
24264 
 
24265 
  def __repr__(self):
24266 
    L = ['%s=%r' % (key, value)
24267 
      for key, value in self.__dict__.iteritems()]
24268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24269 
 
24270 
  def __eq__(self, other):
24271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24272 
 
24273 
  def __ne__(self, other):
24274 
    return not (self == other)
24275 
 
5099 varun.gupt 24276 
class updateOrderAsPaidToVendor_args:
24277 
  """
24278 
  Attributes:
24279 
   - orderId
24280 
  """
24281 
 
24282 
  thrift_spec = (
24283 
    None, # 0
24284 
    (1, TType.I64, 'orderId', None, None, ), # 1
24285 
  )
24286 
 
24287 
  def __init__(self, orderId=None,):
24288 
    self.orderId = orderId
24289 
 
24290 
  def read(self, iprot):
24291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24293 
      return
24294 
    iprot.readStructBegin()
24295 
    while True:
24296 
      (fname, ftype, fid) = iprot.readFieldBegin()
24297 
      if ftype == TType.STOP:
24298 
        break
24299 
      if fid == 1:
24300 
        if ftype == TType.I64:
24301 
          self.orderId = iprot.readI64();
24302 
        else:
24303 
          iprot.skip(ftype)
24304 
      else:
24305 
        iprot.skip(ftype)
24306 
      iprot.readFieldEnd()
24307 
    iprot.readStructEnd()
24308 
 
24309 
  def write(self, oprot):
24310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24312 
      return
24313 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24314 
    if self.orderId is not None:
24315 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24316 
      oprot.writeI64(self.orderId)
24317 
      oprot.writeFieldEnd()
24318 
    oprot.writeFieldStop()
24319 
    oprot.writeStructEnd()
24320 
 
24321 
  def validate(self):
24322 
    return
24323 
 
24324 
 
24325 
  def __repr__(self):
24326 
    L = ['%s=%r' % (key, value)
24327 
      for key, value in self.__dict__.iteritems()]
24328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24329 
 
24330 
  def __eq__(self, other):
24331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24332 
 
24333 
  def __ne__(self, other):
24334 
    return not (self == other)
24335 
 
24336 
class updateOrderAsPaidToVendor_result:
24337 
  """
24338 
  Attributes:
24339 
   - ex
24340 
  """
24341 
 
24342 
  thrift_spec = (
24343 
    None, # 0
24344 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24345 
  )
24346 
 
24347 
  def __init__(self, ex=None,):
24348 
    self.ex = ex
24349 
 
24350 
  def read(self, iprot):
24351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24353 
      return
24354 
    iprot.readStructBegin()
24355 
    while True:
24356 
      (fname, ftype, fid) = iprot.readFieldBegin()
24357 
      if ftype == TType.STOP:
24358 
        break
24359 
      if fid == 1:
24360 
        if ftype == TType.STRUCT:
24361 
          self.ex = TransactionServiceException()
24362 
          self.ex.read(iprot)
24363 
        else:
24364 
          iprot.skip(ftype)
24365 
      else:
24366 
        iprot.skip(ftype)
24367 
      iprot.readFieldEnd()
24368 
    iprot.readStructEnd()
24369 
 
24370 
  def write(self, oprot):
24371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24373 
      return
24374 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24375 
    if self.ex is not None:
24376 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24377 
      self.ex.write(oprot)
24378 
      oprot.writeFieldEnd()
24379 
    oprot.writeFieldStop()
24380 
    oprot.writeStructEnd()
24381 
 
24382 
  def validate(self):
24383 
    return
24384 
 
24385 
 
24386 
  def __repr__(self):
24387 
    L = ['%s=%r' % (key, value)
24388 
      for key, value in self.__dict__.iteritems()]
24389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24390 
 
24391 
  def __eq__(self, other):
24392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24393 
 
24394 
  def __ne__(self, other):
24395 
    return not (self == other)
5208 varun.gupt 24396 
 
5386 phani.kuma 24397 
class updateOrderOnlyAsPaidToVendor_args:
24398 
  """
24399 
  Attributes:
24400 
   - orderId
24401 
  """
24402 
 
24403 
  thrift_spec = (
24404 
    None, # 0
24405 
    (1, TType.I64, 'orderId', None, None, ), # 1
24406 
  )
24407 
 
24408 
  def __init__(self, orderId=None,):
24409 
    self.orderId = orderId
24410 
 
24411 
  def read(self, iprot):
24412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24414 
      return
24415 
    iprot.readStructBegin()
24416 
    while True:
24417 
      (fname, ftype, fid) = iprot.readFieldBegin()
24418 
      if ftype == TType.STOP:
24419 
        break
24420 
      if fid == 1:
24421 
        if ftype == TType.I64:
24422 
          self.orderId = iprot.readI64();
24423 
        else:
24424 
          iprot.skip(ftype)
24425 
      else:
24426 
        iprot.skip(ftype)
24427 
      iprot.readFieldEnd()
24428 
    iprot.readStructEnd()
24429 
 
24430 
  def write(self, oprot):
24431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24433 
      return
24434 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24435 
    if self.orderId is not None:
24436 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24437 
      oprot.writeI64(self.orderId)
24438 
      oprot.writeFieldEnd()
24439 
    oprot.writeFieldStop()
24440 
    oprot.writeStructEnd()
24441 
 
24442 
  def validate(self):
24443 
    return
24444 
 
24445 
 
24446 
  def __repr__(self):
24447 
    L = ['%s=%r' % (key, value)
24448 
      for key, value in self.__dict__.iteritems()]
24449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24450 
 
24451 
  def __eq__(self, other):
24452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24453 
 
24454 
  def __ne__(self, other):
24455 
    return not (self == other)
24456 
 
24457 
class updateOrderOnlyAsPaidToVendor_result:
24458 
  """
24459 
  Attributes:
24460 
   - ex
24461 
  """
24462 
 
24463 
  thrift_spec = (
24464 
    None, # 0
24465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24466 
  )
24467 
 
24468 
  def __init__(self, ex=None,):
24469 
    self.ex = ex
24470 
 
24471 
  def read(self, iprot):
24472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24474 
      return
24475 
    iprot.readStructBegin()
24476 
    while True:
24477 
      (fname, ftype, fid) = iprot.readFieldBegin()
24478 
      if ftype == TType.STOP:
24479 
        break
24480 
      if fid == 1:
24481 
        if ftype == TType.STRUCT:
24482 
          self.ex = TransactionServiceException()
24483 
          self.ex.read(iprot)
24484 
        else:
24485 
          iprot.skip(ftype)
24486 
      else:
24487 
        iprot.skip(ftype)
24488 
      iprot.readFieldEnd()
24489 
    iprot.readStructEnd()
24490 
 
24491 
  def write(self, oprot):
24492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24494 
      return
24495 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24496 
    if self.ex is not None:
24497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24498 
      self.ex.write(oprot)
24499 
      oprot.writeFieldEnd()
24500 
    oprot.writeFieldStop()
24501 
    oprot.writeStructEnd()
24502 
 
24503 
  def validate(self):
24504 
    return
24505 
 
24506 
 
24507 
  def __repr__(self):
24508 
    L = ['%s=%r' % (key, value)
24509 
      for key, value in self.__dict__.iteritems()]
24510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24511 
 
24512 
  def __eq__(self, other):
24513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24514 
 
24515 
  def __ne__(self, other):
24516 
    return not (self == other)
24517 
 
5208 varun.gupt 24518 
class getRefundedOrdersMarkedPaid_args:
24519 
 
24520 
  thrift_spec = (
24521 
  )
24522 
 
24523 
  def read(self, iprot):
24524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24526 
      return
24527 
    iprot.readStructBegin()
24528 
    while True:
24529 
      (fname, ftype, fid) = iprot.readFieldBegin()
24530 
      if ftype == TType.STOP:
24531 
        break
24532 
      else:
24533 
        iprot.skip(ftype)
24534 
      iprot.readFieldEnd()
24535 
    iprot.readStructEnd()
24536 
 
24537 
  def write(self, oprot):
24538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24540 
      return
24541 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24542 
    oprot.writeFieldStop()
24543 
    oprot.writeStructEnd()
24544 
 
24545 
  def validate(self):
24546 
    return
24547 
 
24548 
 
24549 
  def __repr__(self):
24550 
    L = ['%s=%r' % (key, value)
24551 
      for key, value in self.__dict__.iteritems()]
24552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24553 
 
24554 
  def __eq__(self, other):
24555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24556 
 
24557 
  def __ne__(self, other):
24558 
    return not (self == other)
24559 
 
24560 
class getRefundedOrdersMarkedPaid_result:
24561 
  """
24562 
  Attributes:
24563 
   - success
24564 
   - ex
24565 
  """
24566 
 
24567 
  thrift_spec = (
24568 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24569 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24570 
  )
24571 
 
24572 
  def __init__(self, success=None, ex=None,):
24573 
    self.success = success
24574 
    self.ex = ex
24575 
 
24576 
  def read(self, iprot):
24577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24579 
      return
24580 
    iprot.readStructBegin()
24581 
    while True:
24582 
      (fname, ftype, fid) = iprot.readFieldBegin()
24583 
      if ftype == TType.STOP:
24584 
        break
24585 
      if fid == 0:
24586 
        if ftype == TType.LIST:
24587 
          self.success = []
6031 rajveer 24588 
          (_etype567, _size564) = iprot.readListBegin()
24589 
          for _i568 in xrange(_size564):
24590 
            _elem569 = Order()
24591 
            _elem569.read(iprot)
24592 
            self.success.append(_elem569)
5208 varun.gupt 24593 
          iprot.readListEnd()
24594 
        else:
24595 
          iprot.skip(ftype)
24596 
      elif fid == 1:
24597 
        if ftype == TType.STRUCT:
24598 
          self.ex = TransactionServiceException()
24599 
          self.ex.read(iprot)
24600 
        else:
24601 
          iprot.skip(ftype)
24602 
      else:
24603 
        iprot.skip(ftype)
24604 
      iprot.readFieldEnd()
24605 
    iprot.readStructEnd()
24606 
 
24607 
  def write(self, oprot):
24608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24610 
      return
24611 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24612 
    if self.success is not None:
24613 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24614 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24615 
      for iter570 in self.success:
24616 
        iter570.write(oprot)
5208 varun.gupt 24617 
      oprot.writeListEnd()
24618 
      oprot.writeFieldEnd()
24619 
    if self.ex is not None:
24620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24621 
      self.ex.write(oprot)
24622 
      oprot.writeFieldEnd()
24623 
    oprot.writeFieldStop()
24624 
    oprot.writeStructEnd()
24625 
 
24626 
  def validate(self):
24627 
    return
24628 
 
24629 
 
24630 
  def __repr__(self):
24631 
    L = ['%s=%r' % (key, value)
24632 
      for key, value in self.__dict__.iteritems()]
24633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24634 
 
24635 
  def __eq__(self, other):
24636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24637 
 
24638 
  def __ne__(self, other):
24639 
    return not (self == other)
5447 anupam.sin 24640 
 
24641 
class getAllVerificationAgents_args:
24642 
  """
24643 
  Attributes:
24644 
   - minOrderId
24645 
   - maxOrderId
24646 
  """
24647 
 
24648 
  thrift_spec = (
24649 
    None, # 0
24650 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24651 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24652 
  )
24653 
 
24654 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24655 
    self.minOrderId = minOrderId
24656 
    self.maxOrderId = maxOrderId
24657 
 
24658 
  def read(self, iprot):
24659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24661 
      return
24662 
    iprot.readStructBegin()
24663 
    while True:
24664 
      (fname, ftype, fid) = iprot.readFieldBegin()
24665 
      if ftype == TType.STOP:
24666 
        break
24667 
      if fid == 1:
24668 
        if ftype == TType.I64:
24669 
          self.minOrderId = iprot.readI64();
24670 
        else:
24671 
          iprot.skip(ftype)
24672 
      elif fid == 2:
24673 
        if ftype == TType.I64:
24674 
          self.maxOrderId = iprot.readI64();
24675 
        else:
24676 
          iprot.skip(ftype)
24677 
      else:
24678 
        iprot.skip(ftype)
24679 
      iprot.readFieldEnd()
24680 
    iprot.readStructEnd()
24681 
 
24682 
  def write(self, oprot):
24683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24685 
      return
24686 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24687 
    if self.minOrderId is not None:
24688 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24689 
      oprot.writeI64(self.minOrderId)
24690 
      oprot.writeFieldEnd()
24691 
    if self.maxOrderId is not None:
24692 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24693 
      oprot.writeI64(self.maxOrderId)
24694 
      oprot.writeFieldEnd()
24695 
    oprot.writeFieldStop()
24696 
    oprot.writeStructEnd()
24697 
 
24698 
  def validate(self):
24699 
    return
24700 
 
24701 
 
24702 
  def __repr__(self):
24703 
    L = ['%s=%r' % (key, value)
24704 
      for key, value in self.__dict__.iteritems()]
24705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24706 
 
24707 
  def __eq__(self, other):
24708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24709 
 
24710 
  def __ne__(self, other):
24711 
    return not (self == other)
24712 
 
24713 
class getAllVerificationAgents_result:
24714 
  """
24715 
  Attributes:
24716 
   - success
24717 
  """
24718 
 
24719 
  thrift_spec = (
24720 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24721 
  )
24722 
 
24723 
  def __init__(self, success=None,):
24724 
    self.success = success
24725 
 
24726 
  def read(self, iprot):
24727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24729 
      return
24730 
    iprot.readStructBegin()
24731 
    while True:
24732 
      (fname, ftype, fid) = iprot.readFieldBegin()
24733 
      if ftype == TType.STOP:
24734 
        break
24735 
      if fid == 0:
24736 
        if ftype == TType.LIST:
24737 
          self.success = []
6031 rajveer 24738 
          (_etype574, _size571) = iprot.readListBegin()
24739 
          for _i575 in xrange(_size571):
24740 
            _elem576 = CODVerificationAgent()
24741 
            _elem576.read(iprot)
24742 
            self.success.append(_elem576)
5447 anupam.sin 24743 
          iprot.readListEnd()
24744 
        else:
24745 
          iprot.skip(ftype)
24746 
      else:
24747 
        iprot.skip(ftype)
24748 
      iprot.readFieldEnd()
24749 
    iprot.readStructEnd()
24750 
 
24751 
  def write(self, oprot):
24752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24754 
      return
24755 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24756 
    if self.success is not None:
24757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24759 
      for iter577 in self.success:
24760 
        iter577.write(oprot)
5447 anupam.sin 24761 
      oprot.writeListEnd()
24762 
      oprot.writeFieldEnd()
24763 
    oprot.writeFieldStop()
24764 
    oprot.writeStructEnd()
24765 
 
24766 
  def validate(self):
24767 
    return
24768 
 
24769 
 
24770 
  def __repr__(self):
24771 
    L = ['%s=%r' % (key, value)
24772 
      for key, value in self.__dict__.iteritems()]
24773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24774 
 
24775 
  def __eq__(self, other):
24776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24777 
 
24778 
  def __ne__(self, other):
24779 
    return not (self == other)
5527 anupam.sin 24780 
 
24781 
class getAllAttributesForOrderId_args:
24782 
  """
24783 
  Attributes:
24784 
   - orderId
24785 
  """
24786 
 
24787 
  thrift_spec = (
24788 
    None, # 0
24789 
    (1, TType.I64, 'orderId', None, None, ), # 1
24790 
  )
24791 
 
24792 
  def __init__(self, orderId=None,):
24793 
    self.orderId = orderId
24794 
 
24795 
  def read(self, iprot):
24796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24798 
      return
24799 
    iprot.readStructBegin()
24800 
    while True:
24801 
      (fname, ftype, fid) = iprot.readFieldBegin()
24802 
      if ftype == TType.STOP:
24803 
        break
24804 
      if fid == 1:
24805 
        if ftype == TType.I64:
24806 
          self.orderId = iprot.readI64();
24807 
        else:
24808 
          iprot.skip(ftype)
24809 
      else:
24810 
        iprot.skip(ftype)
24811 
      iprot.readFieldEnd()
24812 
    iprot.readStructEnd()
24813 
 
24814 
  def write(self, oprot):
24815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24817 
      return
24818 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24819 
    if self.orderId is not None:
24820 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24821 
      oprot.writeI64(self.orderId)
24822 
      oprot.writeFieldEnd()
24823 
    oprot.writeFieldStop()
24824 
    oprot.writeStructEnd()
24825 
 
24826 
  def validate(self):
24827 
    return
24828 
 
24829 
 
24830 
  def __repr__(self):
24831 
    L = ['%s=%r' % (key, value)
24832 
      for key, value in self.__dict__.iteritems()]
24833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24834 
 
24835 
  def __eq__(self, other):
24836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24837 
 
24838 
  def __ne__(self, other):
24839 
    return not (self == other)
24840 
 
24841 
class getAllAttributesForOrderId_result:
24842 
  """
24843 
  Attributes:
24844 
   - success
24845 
  """
24846 
 
24847 
  thrift_spec = (
24848 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
24849 
  )
24850 
 
24851 
  def __init__(self, success=None,):
24852 
    self.success = success
24853 
 
24854 
  def read(self, iprot):
24855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24857 
      return
24858 
    iprot.readStructBegin()
24859 
    while True:
24860 
      (fname, ftype, fid) = iprot.readFieldBegin()
24861 
      if ftype == TType.STOP:
24862 
        break
24863 
      if fid == 0:
24864 
        if ftype == TType.LIST:
24865 
          self.success = []
6031 rajveer 24866 
          (_etype581, _size578) = iprot.readListBegin()
24867 
          for _i582 in xrange(_size578):
24868 
            _elem583 = Attribute()
24869 
            _elem583.read(iprot)
24870 
            self.success.append(_elem583)
5527 anupam.sin 24871 
          iprot.readListEnd()
24872 
        else:
24873 
          iprot.skip(ftype)
24874 
      else:
24875 
        iprot.skip(ftype)
24876 
      iprot.readFieldEnd()
24877 
    iprot.readStructEnd()
24878 
 
24879 
  def write(self, oprot):
24880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24882 
      return
24883 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
24884 
    if self.success is not None:
24885 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24886 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24887 
      for iter584 in self.success:
24888 
        iter584.write(oprot)
5527 anupam.sin 24889 
      oprot.writeListEnd()
24890 
      oprot.writeFieldEnd()
24891 
    oprot.writeFieldStop()
24892 
    oprot.writeStructEnd()
24893 
 
24894 
  def validate(self):
24895 
    return
24896 
 
24897 
 
24898 
  def __repr__(self):
24899 
    L = ['%s=%r' % (key, value)
24900 
      for key, value in self.__dict__.iteritems()]
24901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24902 
 
24903 
  def __eq__(self, other):
24904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24905 
 
24906 
  def __ne__(self, other):
24907 
    return not (self == other)
24908 
 
5676 rajveer 24909 
class setOrderAttributes_args:
24910 
  """
24911 
  Attributes:
24912 
   - orderId
24913 
   - attributes
24914 
  """
24915 
 
24916 
  thrift_spec = None
24917 
  def __init__(self, orderId=None, attributes=None,):
24918 
    self.orderId = orderId
24919 
    self.attributes = attributes
24920 
 
24921 
  def read(self, iprot):
24922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24924 
      return
24925 
    iprot.readStructBegin()
24926 
    while True:
24927 
      (fname, ftype, fid) = iprot.readFieldBegin()
24928 
      if ftype == TType.STOP:
24929 
        break
24930 
      if fid == 1:
24931 
        if ftype == TType.I64:
24932 
          self.orderId = iprot.readI64();
24933 
        else:
24934 
          iprot.skip(ftype)
24935 
      elif fid == -1:
24936 
        if ftype == TType.LIST:
24937 
          self.attributes = []
6031 rajveer 24938 
          (_etype588, _size585) = iprot.readListBegin()
24939 
          for _i589 in xrange(_size585):
24940 
            _elem590 = Attribute()
24941 
            _elem590.read(iprot)
24942 
            self.attributes.append(_elem590)
5676 rajveer 24943 
          iprot.readListEnd()
24944 
        else:
24945 
          iprot.skip(ftype)
24946 
      else:
24947 
        iprot.skip(ftype)
24948 
      iprot.readFieldEnd()
24949 
    iprot.readStructEnd()
24950 
 
24951 
  def write(self, oprot):
24952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24954 
      return
24955 
    oprot.writeStructBegin('setOrderAttributes_args')
24956 
    if self.attributes is not None:
24957 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
24958 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6031 rajveer 24959 
      for iter591 in self.attributes:
24960 
        iter591.write(oprot)
5676 rajveer 24961 
      oprot.writeListEnd()
24962 
      oprot.writeFieldEnd()
24963 
    if self.orderId is not None:
24964 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24965 
      oprot.writeI64(self.orderId)
24966 
      oprot.writeFieldEnd()
24967 
    oprot.writeFieldStop()
24968 
    oprot.writeStructEnd()
24969 
 
24970 
  def validate(self):
24971 
    return
24972 
 
24973 
 
24974 
  def __repr__(self):
24975 
    L = ['%s=%r' % (key, value)
24976 
      for key, value in self.__dict__.iteritems()]
24977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24978 
 
24979 
  def __eq__(self, other):
24980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24981 
 
24982 
  def __ne__(self, other):
24983 
    return not (self == other)
24984 
 
24985 
class setOrderAttributes_result:
24986 
 
24987 
  thrift_spec = (
24988 
  )
24989 
 
24990 
  def read(self, iprot):
24991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24993 
      return
24994 
    iprot.readStructBegin()
24995 
    while True:
24996 
      (fname, ftype, fid) = iprot.readFieldBegin()
24997 
      if ftype == TType.STOP:
24998 
        break
24999 
      else:
25000 
        iprot.skip(ftype)
25001 
      iprot.readFieldEnd()
25002 
    iprot.readStructEnd()
25003 
 
25004 
  def write(self, oprot):
25005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25007 
      return
25008 
    oprot.writeStructBegin('setOrderAttributes_result')
25009 
    oprot.writeFieldStop()
25010 
    oprot.writeStructEnd()
25011 
 
25012 
  def validate(self):
25013 
    return
25014 
 
25015 
 
25016 
  def __repr__(self):
25017 
    L = ['%s=%r' % (key, value)
25018 
      for key, value in self.__dict__.iteritems()]
25019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25020 
 
25021 
  def __eq__(self, other):
25022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25023 
 
25024 
  def __ne__(self, other):
25025 
    return not (self == other)
25026 
 
5527 anupam.sin 25027 
class setOrderAttributeForTransaction_args:
25028 
  """
25029 
  Attributes:
25030 
   - transactionId
25031 
   - attribute
25032 
  """
25033 
 
25034 
  thrift_spec = None
25035 
  def __init__(self, transactionId=None, attribute=None,):
25036 
    self.transactionId = transactionId
25037 
    self.attribute = attribute
25038 
 
25039 
  def read(self, iprot):
25040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25042 
      return
25043 
    iprot.readStructBegin()
25044 
    while True:
25045 
      (fname, ftype, fid) = iprot.readFieldBegin()
25046 
      if ftype == TType.STOP:
25047 
        break
25048 
      if fid == 1:
25049 
        if ftype == TType.I64:
25050 
          self.transactionId = iprot.readI64();
25051 
        else:
25052 
          iprot.skip(ftype)
25053 
      elif fid == -1:
25054 
        if ftype == TType.STRUCT:
25055 
          self.attribute = Attribute()
25056 
          self.attribute.read(iprot)
25057 
        else:
25058 
          iprot.skip(ftype)
25059 
      else:
25060 
        iprot.skip(ftype)
25061 
      iprot.readFieldEnd()
25062 
    iprot.readStructEnd()
25063 
 
25064 
  def write(self, oprot):
25065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25067 
      return
25068 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25069 
    if self.attribute is not None:
25070 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25071 
      self.attribute.write(oprot)
25072 
      oprot.writeFieldEnd()
25073 
    if self.transactionId is not None:
25074 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25075 
      oprot.writeI64(self.transactionId)
25076 
      oprot.writeFieldEnd()
25077 
    oprot.writeFieldStop()
25078 
    oprot.writeStructEnd()
25079 
 
25080 
  def validate(self):
25081 
    return
25082 
 
25083 
 
25084 
  def __repr__(self):
25085 
    L = ['%s=%r' % (key, value)
25086 
      for key, value in self.__dict__.iteritems()]
25087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25088 
 
25089 
  def __eq__(self, other):
25090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25091 
 
25092 
  def __ne__(self, other):
25093 
    return not (self == other)
25094 
 
25095 
class setOrderAttributeForTransaction_result:
25096 
 
25097 
  thrift_spec = (
25098 
  )
25099 
 
25100 
  def read(self, iprot):
25101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25103 
      return
25104 
    iprot.readStructBegin()
25105 
    while True:
25106 
      (fname, ftype, fid) = iprot.readFieldBegin()
25107 
      if ftype == TType.STOP:
25108 
        break
25109 
      else:
25110 
        iprot.skip(ftype)
25111 
      iprot.readFieldEnd()
25112 
    iprot.readStructEnd()
25113 
 
25114 
  def write(self, oprot):
25115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25117 
      return
25118 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25119 
    oprot.writeFieldStop()
25120 
    oprot.writeStructEnd()
25121 
 
25122 
  def validate(self):
25123 
    return
25124 
 
25125 
 
25126 
  def __repr__(self):
25127 
    L = ['%s=%r' % (key, value)
25128 
      for key, value in self.__dict__.iteritems()]
25129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25130 
 
25131 
  def __eq__(self, other):
25132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25133 
 
25134 
  def __ne__(self, other):
25135 
    return not (self == other)
5553 rajveer 25136 
 
25137 
class getReceivePendingOrders_args:
25138 
  """
25139 
  Attributes:
25140 
   - storeId
25141 
  """
25142 
 
25143 
  thrift_spec = (
25144 
    None, # 0
25145 
    (1, TType.I64, 'storeId', None, None, ), # 1
25146 
  )
25147 
 
25148 
  def __init__(self, storeId=None,):
25149 
    self.storeId = storeId
25150 
 
25151 
  def read(self, iprot):
25152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25154 
      return
25155 
    iprot.readStructBegin()
25156 
    while True:
25157 
      (fname, ftype, fid) = iprot.readFieldBegin()
25158 
      if ftype == TType.STOP:
25159 
        break
25160 
      if fid == 1:
25161 
        if ftype == TType.I64:
25162 
          self.storeId = iprot.readI64();
25163 
        else:
25164 
          iprot.skip(ftype)
25165 
      else:
25166 
        iprot.skip(ftype)
25167 
      iprot.readFieldEnd()
25168 
    iprot.readStructEnd()
25169 
 
25170 
  def write(self, oprot):
25171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25173 
      return
25174 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25175 
    if self.storeId is not None:
25176 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25177 
      oprot.writeI64(self.storeId)
25178 
      oprot.writeFieldEnd()
25179 
    oprot.writeFieldStop()
25180 
    oprot.writeStructEnd()
25181 
 
25182 
  def validate(self):
25183 
    return
25184 
 
25185 
 
25186 
  def __repr__(self):
25187 
    L = ['%s=%r' % (key, value)
25188 
      for key, value in self.__dict__.iteritems()]
25189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25190 
 
25191 
  def __eq__(self, other):
25192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25193 
 
25194 
  def __ne__(self, other):
25195 
    return not (self == other)
25196 
 
25197 
class getReceivePendingOrders_result:
25198 
  """
25199 
  Attributes:
25200 
   - success
25201 
  """
25202 
 
25203 
  thrift_spec = (
25204 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25205 
  )
25206 
 
25207 
  def __init__(self, success=None,):
25208 
    self.success = success
25209 
 
25210 
  def read(self, iprot):
25211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25213 
      return
25214 
    iprot.readStructBegin()
25215 
    while True:
25216 
      (fname, ftype, fid) = iprot.readFieldBegin()
25217 
      if ftype == TType.STOP:
25218 
        break
25219 
      if fid == 0:
25220 
        if ftype == TType.LIST:
25221 
          self.success = []
6031 rajveer 25222 
          (_etype595, _size592) = iprot.readListBegin()
25223 
          for _i596 in xrange(_size592):
25224 
            _elem597 = Order()
25225 
            _elem597.read(iprot)
25226 
            self.success.append(_elem597)
5553 rajveer 25227 
          iprot.readListEnd()
25228 
        else:
25229 
          iprot.skip(ftype)
25230 
      else:
25231 
        iprot.skip(ftype)
25232 
      iprot.readFieldEnd()
25233 
    iprot.readStructEnd()
25234 
 
25235 
  def write(self, oprot):
25236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25238 
      return
25239 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25240 
    if self.success is not None:
25241 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25242 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25243 
      for iter598 in self.success:
25244 
        iter598.write(oprot)
5553 rajveer 25245 
      oprot.writeListEnd()
25246 
      oprot.writeFieldEnd()
25247 
    oprot.writeFieldStop()
25248 
    oprot.writeStructEnd()
25249 
 
25250 
  def validate(self):
25251 
    return
25252 
 
25253 
 
25254 
  def __repr__(self):
25255 
    L = ['%s=%r' % (key, value)
25256 
      for key, value in self.__dict__.iteritems()]
25257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25258 
 
25259 
  def __eq__(self, other):
25260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25261 
 
25262 
  def __ne__(self, other):
25263 
    return not (self == other)
25264 
 
25265 
class getReceivedAtStoreOrders_args:
25266 
  """
25267 
  Attributes:
25268 
   - storeId
25269 
  """
25270 
 
25271 
  thrift_spec = (
25272 
    None, # 0
25273 
    (1, TType.I64, 'storeId', None, None, ), # 1
25274 
  )
25275 
 
25276 
  def __init__(self, storeId=None,):
25277 
    self.storeId = storeId
25278 
 
25279 
  def read(self, iprot):
25280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25282 
      return
25283 
    iprot.readStructBegin()
25284 
    while True:
25285 
      (fname, ftype, fid) = iprot.readFieldBegin()
25286 
      if ftype == TType.STOP:
25287 
        break
25288 
      if fid == 1:
25289 
        if ftype == TType.I64:
25290 
          self.storeId = iprot.readI64();
25291 
        else:
25292 
          iprot.skip(ftype)
25293 
      else:
25294 
        iprot.skip(ftype)
25295 
      iprot.readFieldEnd()
25296 
    iprot.readStructEnd()
25297 
 
25298 
  def write(self, oprot):
25299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25301 
      return
25302 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25303 
    if self.storeId is not None:
25304 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25305 
      oprot.writeI64(self.storeId)
25306 
      oprot.writeFieldEnd()
25307 
    oprot.writeFieldStop()
25308 
    oprot.writeStructEnd()
25309 
 
25310 
  def validate(self):
25311 
    return
25312 
 
25313 
 
25314 
  def __repr__(self):
25315 
    L = ['%s=%r' % (key, value)
25316 
      for key, value in self.__dict__.iteritems()]
25317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25318 
 
25319 
  def __eq__(self, other):
25320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25321 
 
25322 
  def __ne__(self, other):
25323 
    return not (self == other)
25324 
 
25325 
class getReceivedAtStoreOrders_result:
25326 
  """
25327 
  Attributes:
25328 
   - success
25329 
  """
25330 
 
25331 
  thrift_spec = (
25332 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25333 
  )
25334 
 
25335 
  def __init__(self, success=None,):
25336 
    self.success = success
25337 
 
25338 
  def read(self, iprot):
25339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25341 
      return
25342 
    iprot.readStructBegin()
25343 
    while True:
25344 
      (fname, ftype, fid) = iprot.readFieldBegin()
25345 
      if ftype == TType.STOP:
25346 
        break
25347 
      if fid == 0:
25348 
        if ftype == TType.LIST:
25349 
          self.success = []
6031 rajveer 25350 
          (_etype602, _size599) = iprot.readListBegin()
25351 
          for _i603 in xrange(_size599):
25352 
            _elem604 = Order()
25353 
            _elem604.read(iprot)
25354 
            self.success.append(_elem604)
5553 rajveer 25355 
          iprot.readListEnd()
25356 
        else:
25357 
          iprot.skip(ftype)
25358 
      else:
25359 
        iprot.skip(ftype)
25360 
      iprot.readFieldEnd()
25361 
    iprot.readStructEnd()
25362 
 
25363 
  def write(self, oprot):
25364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25366 
      return
25367 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25368 
    if self.success is not None:
25369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25370 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25371 
      for iter605 in self.success:
25372 
        iter605.write(oprot)
5553 rajveer 25373 
      oprot.writeListEnd()
25374 
      oprot.writeFieldEnd()
25375 
    oprot.writeFieldStop()
25376 
    oprot.writeStructEnd()
25377 
 
25378 
  def validate(self):
25379 
    return
25380 
 
25381 
 
25382 
  def __repr__(self):
25383 
    L = ['%s=%r' % (key, value)
25384 
      for key, value in self.__dict__.iteritems()]
25385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25386 
 
25387 
  def __eq__(self, other):
25388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25389 
 
25390 
  def __ne__(self, other):
25391 
    return not (self == other)
5593 mandeep.dh 25392 
 
5713 rajveer 25393 
class getOrdersCollectionAtStore_args:
25394 
  """
25395 
  Attributes:
25396 
   - storeId
25397 
   - fromDate
25398 
   - toDate
25399 
   - onlyCod
25400 
  """
25401 
 
25402 
  thrift_spec = (
25403 
    None, # 0
25404 
    (1, TType.I64, 'storeId', None, None, ), # 1
25405 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25406 
    (3, TType.I64, 'toDate', None, None, ), # 3
25407 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25408 
  )
25409 
 
25410 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25411 
    self.storeId = storeId
25412 
    self.fromDate = fromDate
25413 
    self.toDate = toDate
25414 
    self.onlyCod = onlyCod
25415 
 
25416 
  def read(self, iprot):
25417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25419 
      return
25420 
    iprot.readStructBegin()
25421 
    while True:
25422 
      (fname, ftype, fid) = iprot.readFieldBegin()
25423 
      if ftype == TType.STOP:
25424 
        break
25425 
      if fid == 1:
25426 
        if ftype == TType.I64:
25427 
          self.storeId = iprot.readI64();
25428 
        else:
25429 
          iprot.skip(ftype)
25430 
      elif fid == 2:
25431 
        if ftype == TType.I64:
25432 
          self.fromDate = iprot.readI64();
25433 
        else:
25434 
          iprot.skip(ftype)
25435 
      elif fid == 3:
25436 
        if ftype == TType.I64:
25437 
          self.toDate = iprot.readI64();
25438 
        else:
25439 
          iprot.skip(ftype)
25440 
      elif fid == 4:
25441 
        if ftype == TType.BOOL:
25442 
          self.onlyCod = iprot.readBool();
25443 
        else:
25444 
          iprot.skip(ftype)
25445 
      else:
25446 
        iprot.skip(ftype)
25447 
      iprot.readFieldEnd()
25448 
    iprot.readStructEnd()
25449 
 
25450 
  def write(self, oprot):
25451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25453 
      return
25454 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25455 
    if self.storeId is not None:
25456 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25457 
      oprot.writeI64(self.storeId)
25458 
      oprot.writeFieldEnd()
25459 
    if self.fromDate is not None:
25460 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25461 
      oprot.writeI64(self.fromDate)
25462 
      oprot.writeFieldEnd()
25463 
    if self.toDate is not None:
25464 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25465 
      oprot.writeI64(self.toDate)
25466 
      oprot.writeFieldEnd()
25467 
    if self.onlyCod is not None:
25468 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25469 
      oprot.writeBool(self.onlyCod)
25470 
      oprot.writeFieldEnd()
25471 
    oprot.writeFieldStop()
25472 
    oprot.writeStructEnd()
25473 
 
25474 
  def validate(self):
25475 
    return
25476 
 
25477 
 
25478 
  def __repr__(self):
25479 
    L = ['%s=%r' % (key, value)
25480 
      for key, value in self.__dict__.iteritems()]
25481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25482 
 
25483 
  def __eq__(self, other):
25484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25485 
 
25486 
  def __ne__(self, other):
25487 
    return not (self == other)
25488 
 
25489 
class getOrdersCollectionAtStore_result:
25490 
  """
25491 
  Attributes:
25492 
   - success
25493 
  """
25494 
 
25495 
  thrift_spec = (
25496 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25497 
  )
25498 
 
25499 
  def __init__(self, success=None,):
25500 
    self.success = success
25501 
 
25502 
  def read(self, iprot):
25503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25505 
      return
25506 
    iprot.readStructBegin()
25507 
    while True:
25508 
      (fname, ftype, fid) = iprot.readFieldBegin()
25509 
      if ftype == TType.STOP:
25510 
        break
25511 
      if fid == 0:
25512 
        if ftype == TType.LIST:
25513 
          self.success = []
6031 rajveer 25514 
          (_etype609, _size606) = iprot.readListBegin()
25515 
          for _i610 in xrange(_size606):
25516 
            _elem611 = Order()
25517 
            _elem611.read(iprot)
25518 
            self.success.append(_elem611)
5713 rajveer 25519 
          iprot.readListEnd()
25520 
        else:
25521 
          iprot.skip(ftype)
25522 
      else:
25523 
        iprot.skip(ftype)
25524 
      iprot.readFieldEnd()
25525 
    iprot.readStructEnd()
25526 
 
25527 
  def write(self, oprot):
25528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25530 
      return
25531 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25532 
    if self.success is not None:
25533 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25534 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25535 
      for iter612 in self.success:
25536 
        iter612.write(oprot)
5713 rajveer 25537 
      oprot.writeListEnd()
25538 
      oprot.writeFieldEnd()
25539 
    oprot.writeFieldStop()
25540 
    oprot.writeStructEnd()
25541 
 
25542 
  def validate(self):
25543 
    return
25544 
 
25545 
 
25546 
  def __repr__(self):
25547 
    L = ['%s=%r' % (key, value)
25548 
      for key, value in self.__dict__.iteritems()]
25549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25550 
 
25551 
  def __eq__(self, other):
25552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25553 
 
25554 
  def __ne__(self, other):
25555 
    return not (self == other)
25556 
 
5833 rajveer 25557 
class getOrderAttributeValue_args:
25558 
  """
25559 
  Attributes:
25560 
   - orderId
25561 
   - attributeName
25562 
  """
25563 
 
25564 
  thrift_spec = None
25565 
  def __init__(self, orderId=None, attributeName=None,):
25566 
    self.orderId = orderId
25567 
    self.attributeName = attributeName
25568 
 
25569 
  def read(self, iprot):
25570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25572 
      return
25573 
    iprot.readStructBegin()
25574 
    while True:
25575 
      (fname, ftype, fid) = iprot.readFieldBegin()
25576 
      if ftype == TType.STOP:
25577 
        break
25578 
      if fid == 1:
25579 
        if ftype == TType.I64:
25580 
          self.orderId = iprot.readI64();
25581 
        else:
25582 
          iprot.skip(ftype)
25583 
      elif fid == -1:
25584 
        if ftype == TType.STRING:
25585 
          self.attributeName = iprot.readString();
25586 
        else:
25587 
          iprot.skip(ftype)
25588 
      else:
25589 
        iprot.skip(ftype)
25590 
      iprot.readFieldEnd()
25591 
    iprot.readStructEnd()
25592 
 
25593 
  def write(self, oprot):
25594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25596 
      return
25597 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25598 
    if self.attributeName is not None:
25599 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25600 
      oprot.writeString(self.attributeName)
25601 
      oprot.writeFieldEnd()
25602 
    if self.orderId is not None:
25603 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25604 
      oprot.writeI64(self.orderId)
25605 
      oprot.writeFieldEnd()
25606 
    oprot.writeFieldStop()
25607 
    oprot.writeStructEnd()
25608 
 
25609 
  def validate(self):
25610 
    return
25611 
 
25612 
 
25613 
  def __repr__(self):
25614 
    L = ['%s=%r' % (key, value)
25615 
      for key, value in self.__dict__.iteritems()]
25616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25617 
 
25618 
  def __eq__(self, other):
25619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25620 
 
25621 
  def __ne__(self, other):
25622 
    return not (self == other)
25623 
 
25624 
class getOrderAttributeValue_result:
25625 
  """
25626 
  Attributes:
25627 
   - success
25628 
  """
25629 
 
25630 
  thrift_spec = (
25631 
    (0, TType.STRING, 'success', None, None, ), # 0
25632 
  )
25633 
 
25634 
  def __init__(self, success=None,):
25635 
    self.success = success
25636 
 
25637 
  def read(self, iprot):
25638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25640 
      return
25641 
    iprot.readStructBegin()
25642 
    while True:
25643 
      (fname, ftype, fid) = iprot.readFieldBegin()
25644 
      if ftype == TType.STOP:
25645 
        break
25646 
      if fid == 0:
25647 
        if ftype == TType.STRING:
25648 
          self.success = iprot.readString();
25649 
        else:
25650 
          iprot.skip(ftype)
25651 
      else:
25652 
        iprot.skip(ftype)
25653 
      iprot.readFieldEnd()
25654 
    iprot.readStructEnd()
25655 
 
25656 
  def write(self, oprot):
25657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25659 
      return
25660 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25661 
    if self.success is not None:
25662 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25663 
      oprot.writeString(self.success)
25664 
      oprot.writeFieldEnd()
25665 
    oprot.writeFieldStop()
25666 
    oprot.writeStructEnd()
25667 
 
25668 
  def validate(self):
25669 
    return
25670 
 
25671 
 
25672 
  def __repr__(self):
25673 
    L = ['%s=%r' % (key, value)
25674 
      for key, value in self.__dict__.iteritems()]
25675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25676 
 
25677 
  def __eq__(self, other):
25678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25679 
 
25680 
  def __ne__(self, other):
25681 
    return not (self == other)
25682 
 
6019 rajveer 25683 
class changeJacketNumber_args:
25684 
  """
25685 
  Attributes:
25686 
   - orderId
25687 
   - jacketNumber
25688 
  """
25689 
 
25690 
  thrift_spec = (
25691 
    None, # 0
25692 
    (1, TType.I64, 'orderId', None, None, ), # 1
25693 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
25694 
  )
25695 
 
25696 
  def __init__(self, orderId=None, jacketNumber=None,):
25697 
    self.orderId = orderId
25698 
    self.jacketNumber = jacketNumber
25699 
 
25700 
  def read(self, iprot):
25701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25703 
      return
25704 
    iprot.readStructBegin()
25705 
    while True:
25706 
      (fname, ftype, fid) = iprot.readFieldBegin()
25707 
      if ftype == TType.STOP:
25708 
        break
25709 
      if fid == 1:
25710 
        if ftype == TType.I64:
25711 
          self.orderId = iprot.readI64();
25712 
        else:
25713 
          iprot.skip(ftype)
25714 
      elif fid == 2:
25715 
        if ftype == TType.I64:
25716 
          self.jacketNumber = iprot.readI64();
25717 
        else:
25718 
          iprot.skip(ftype)
25719 
      else:
25720 
        iprot.skip(ftype)
25721 
      iprot.readFieldEnd()
25722 
    iprot.readStructEnd()
25723 
 
25724 
  def write(self, oprot):
25725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25727 
      return
25728 
    oprot.writeStructBegin('changeJacketNumber_args')
25729 
    if self.orderId is not None:
25730 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25731 
      oprot.writeI64(self.orderId)
25732 
      oprot.writeFieldEnd()
25733 
    if self.jacketNumber is not None:
25734 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
25735 
      oprot.writeI64(self.jacketNumber)
25736 
      oprot.writeFieldEnd()
25737 
    oprot.writeFieldStop()
25738 
    oprot.writeStructEnd()
25739 
 
25740 
  def validate(self):
25741 
    return
25742 
 
25743 
 
25744 
  def __repr__(self):
25745 
    L = ['%s=%r' % (key, value)
25746 
      for key, value in self.__dict__.iteritems()]
25747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25748 
 
25749 
  def __eq__(self, other):
25750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25751 
 
25752 
  def __ne__(self, other):
25753 
    return not (self == other)
25754 
 
25755 
class changeJacketNumber_result:
25756 
  """
25757 
  Attributes:
25758 
   - success
25759 
  """
25760 
 
25761 
  thrift_spec = (
25762 
    (0, TType.BOOL, 'success', None, None, ), # 0
25763 
  )
25764 
 
25765 
  def __init__(self, success=None,):
25766 
    self.success = success
25767 
 
25768 
  def read(self, iprot):
25769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25771 
      return
25772 
    iprot.readStructBegin()
25773 
    while True:
25774 
      (fname, ftype, fid) = iprot.readFieldBegin()
25775 
      if ftype == TType.STOP:
25776 
        break
25777 
      if fid == 0:
25778 
        if ftype == TType.BOOL:
25779 
          self.success = iprot.readBool();
25780 
        else:
25781 
          iprot.skip(ftype)
25782 
      else:
25783 
        iprot.skip(ftype)
25784 
      iprot.readFieldEnd()
25785 
    iprot.readStructEnd()
25786 
 
25787 
  def write(self, oprot):
25788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25790 
      return
25791 
    oprot.writeStructBegin('changeJacketNumber_result')
25792 
    if self.success is not None:
25793 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25794 
      oprot.writeBool(self.success)
25795 
      oprot.writeFieldEnd()
25796 
    oprot.writeFieldStop()
25797 
    oprot.writeStructEnd()
25798 
 
25799 
  def validate(self):
25800 
    return
25801 
 
25802 
 
25803 
  def __repr__(self):
25804 
    L = ['%s=%r' % (key, value)
25805 
      for key, value in self.__dict__.iteritems()]
25806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25807 
 
25808 
  def __eq__(self, other):
25809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25810 
 
25811 
  def __ne__(self, other):
25812 
    return not (self == other)
25813 
 
25814 
class markOrderAsRtoInTransit_args:
25815 
  """
25816 
  Attributes:
25817 
   - orderId
25818 
  """
25819 
 
25820 
  thrift_spec = (
25821 
    None, # 0
25822 
    (1, TType.I64, 'orderId', None, None, ), # 1
25823 
  )
25824 
 
25825 
  def __init__(self, orderId=None,):
25826 
    self.orderId = orderId
25827 
 
25828 
  def read(self, iprot):
25829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25831 
      return
25832 
    iprot.readStructBegin()
25833 
    while True:
25834 
      (fname, ftype, fid) = iprot.readFieldBegin()
25835 
      if ftype == TType.STOP:
25836 
        break
25837 
      if fid == 1:
25838 
        if ftype == TType.I64:
25839 
          self.orderId = iprot.readI64();
25840 
        else:
25841 
          iprot.skip(ftype)
25842 
      else:
25843 
        iprot.skip(ftype)
25844 
      iprot.readFieldEnd()
25845 
    iprot.readStructEnd()
25846 
 
25847 
  def write(self, oprot):
25848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25850 
      return
25851 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
25852 
    if self.orderId is not None:
25853 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25854 
      oprot.writeI64(self.orderId)
25855 
      oprot.writeFieldEnd()
25856 
    oprot.writeFieldStop()
25857 
    oprot.writeStructEnd()
25858 
 
25859 
  def validate(self):
25860 
    return
25861 
 
25862 
 
25863 
  def __repr__(self):
25864 
    L = ['%s=%r' % (key, value)
25865 
      for key, value in self.__dict__.iteritems()]
25866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25867 
 
25868 
  def __eq__(self, other):
25869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25870 
 
25871 
  def __ne__(self, other):
25872 
    return not (self == other)
25873 
 
25874 
class markOrderAsRtoInTransit_result:
25875 
  """
25876 
  Attributes:
25877 
   - success
25878 
  """
25879 
 
25880 
  thrift_spec = (
25881 
    (0, TType.BOOL, 'success', None, None, ), # 0
25882 
  )
25883 
 
25884 
  def __init__(self, success=None,):
25885 
    self.success = success
25886 
 
25887 
  def read(self, iprot):
25888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25890 
      return
25891 
    iprot.readStructBegin()
25892 
    while True:
25893 
      (fname, ftype, fid) = iprot.readFieldBegin()
25894 
      if ftype == TType.STOP:
25895 
        break
25896 
      if fid == 0:
25897 
        if ftype == TType.BOOL:
25898 
          self.success = iprot.readBool();
25899 
        else:
25900 
          iprot.skip(ftype)
25901 
      else:
25902 
        iprot.skip(ftype)
25903 
      iprot.readFieldEnd()
25904 
    iprot.readStructEnd()
25905 
 
25906 
  def write(self, oprot):
25907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25909 
      return
25910 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
25911 
    if self.success is not None:
25912 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25913 
      oprot.writeBool(self.success)
25914 
      oprot.writeFieldEnd()
25915 
    oprot.writeFieldStop()
25916 
    oprot.writeStructEnd()
25917 
 
25918 
  def validate(self):
25919 
    return
25920 
 
25921 
 
25922 
  def __repr__(self):
25923 
    L = ['%s=%r' % (key, value)
25924 
      for key, value in self.__dict__.iteritems()]
25925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25926 
 
25927 
  def __eq__(self, other):
25928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25929 
 
25930 
  def __ne__(self, other):
25931 
    return not (self == other)
25932 
 
5593 mandeep.dh 25933 
class acceptOrderForItem_args:
25934 
  """
25935 
  Attributes:
25936 
   - itemId
25937 
   - quantity
25938 
   - fulfilmentWarehouseId
25939 
   - billingWarehouseId
25940 
  """
25941 
 
25942 
  thrift_spec = (
25943 
    None, # 0
25944 
    (1, TType.I64, 'itemId', None, None, ), # 1
25945 
    (2, TType.I64, 'quantity', None, None, ), # 2
25946 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
25947 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
25948 
  )
25949 
 
25950 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
25951 
    self.itemId = itemId
25952 
    self.quantity = quantity
25953 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
25954 
    self.billingWarehouseId = billingWarehouseId
25955 
 
25956 
  def read(self, iprot):
25957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25959 
      return
25960 
    iprot.readStructBegin()
25961 
    while True:
25962 
      (fname, ftype, fid) = iprot.readFieldBegin()
25963 
      if ftype == TType.STOP:
25964 
        break
25965 
      if fid == 1:
25966 
        if ftype == TType.I64:
25967 
          self.itemId = iprot.readI64();
25968 
        else:
25969 
          iprot.skip(ftype)
25970 
      elif fid == 2:
25971 
        if ftype == TType.I64:
25972 
          self.quantity = iprot.readI64();
25973 
        else:
25974 
          iprot.skip(ftype)
25975 
      elif fid == 3:
25976 
        if ftype == TType.I64:
25977 
          self.fulfilmentWarehouseId = iprot.readI64();
25978 
        else:
25979 
          iprot.skip(ftype)
25980 
      elif fid == 4:
25981 
        if ftype == TType.I64:
25982 
          self.billingWarehouseId = iprot.readI64();
25983 
        else:
25984 
          iprot.skip(ftype)
25985 
      else:
25986 
        iprot.skip(ftype)
25987 
      iprot.readFieldEnd()
25988 
    iprot.readStructEnd()
25989 
 
25990 
  def write(self, oprot):
25991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25993 
      return
25994 
    oprot.writeStructBegin('acceptOrderForItem_args')
25995 
    if self.itemId is not None:
25996 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25997 
      oprot.writeI64(self.itemId)
25998 
      oprot.writeFieldEnd()
25999 
    if self.quantity is not None:
26000 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26001 
      oprot.writeI64(self.quantity)
26002 
      oprot.writeFieldEnd()
26003 
    if self.fulfilmentWarehouseId is not None:
26004 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26005 
      oprot.writeI64(self.fulfilmentWarehouseId)
26006 
      oprot.writeFieldEnd()
26007 
    if self.billingWarehouseId is not None:
26008 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26009 
      oprot.writeI64(self.billingWarehouseId)
26010 
      oprot.writeFieldEnd()
26011 
    oprot.writeFieldStop()
26012 
    oprot.writeStructEnd()
26013 
 
26014 
  def validate(self):
26015 
    return
26016 
 
26017 
 
26018 
  def __repr__(self):
26019 
    L = ['%s=%r' % (key, value)
26020 
      for key, value in self.__dict__.iteritems()]
26021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26022 
 
26023 
  def __eq__(self, other):
26024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26025 
 
26026 
  def __ne__(self, other):
26027 
    return not (self == other)
26028 
 
26029 
class acceptOrderForItem_result:
26030 
 
26031 
  thrift_spec = (
26032 
  )
26033 
 
26034 
  def read(self, iprot):
26035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26037 
      return
26038 
    iprot.readStructBegin()
26039 
    while True:
26040 
      (fname, ftype, fid) = iprot.readFieldBegin()
26041 
      if ftype == TType.STOP:
26042 
        break
26043 
      else:
26044 
        iprot.skip(ftype)
26045 
      iprot.readFieldEnd()
26046 
    iprot.readStructEnd()
26047 
 
26048 
  def write(self, oprot):
26049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26051 
      return
26052 
    oprot.writeStructBegin('acceptOrderForItem_result')
26053 
    oprot.writeFieldStop()
26054 
    oprot.writeStructEnd()
26055 
 
26056 
  def validate(self):
26057 
    return
26058 
 
26059 
 
26060 
  def __repr__(self):
26061 
    L = ['%s=%r' % (key, value)
26062 
      for key, value in self.__dict__.iteritems()]
26063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26064 
 
26065 
  def __eq__(self, other):
26066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26067 
 
26068 
  def __ne__(self, other):
26069 
    return not (self == other)
6000 mandeep.dh 26070 
 
26071 
class createRechargeOrder_args:
26072 
  """
26073 
  Attributes:
26074 
   - rechargeOrder
26075 
  """
26076 
 
26077 
  thrift_spec = (
26078 
    None, # 0
26079 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26080 
  )
26081 
 
26082 
  def __init__(self, rechargeOrder=None,):
26083 
    self.rechargeOrder = rechargeOrder
26084 
 
26085 
  def read(self, iprot):
26086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26088 
      return
26089 
    iprot.readStructBegin()
26090 
    while True:
26091 
      (fname, ftype, fid) = iprot.readFieldBegin()
26092 
      if ftype == TType.STOP:
26093 
        break
26094 
      if fid == 1:
26095 
        if ftype == TType.STRUCT:
26096 
          self.rechargeOrder = RechargeOrder()
26097 
          self.rechargeOrder.read(iprot)
26098 
        else:
26099 
          iprot.skip(ftype)
26100 
      else:
26101 
        iprot.skip(ftype)
26102 
      iprot.readFieldEnd()
26103 
    iprot.readStructEnd()
26104 
 
26105 
  def write(self, oprot):
26106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26108 
      return
26109 
    oprot.writeStructBegin('createRechargeOrder_args')
26110 
    if self.rechargeOrder is not None:
26111 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26112 
      self.rechargeOrder.write(oprot)
26113 
      oprot.writeFieldEnd()
26114 
    oprot.writeFieldStop()
26115 
    oprot.writeStructEnd()
26116 
 
26117 
  def validate(self):
26118 
    return
26119 
 
26120 
 
26121 
  def __repr__(self):
26122 
    L = ['%s=%r' % (key, value)
26123 
      for key, value in self.__dict__.iteritems()]
26124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26125 
 
26126 
  def __eq__(self, other):
26127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26128 
 
26129 
  def __ne__(self, other):
26130 
    return not (self == other)
26131 
 
26132 
class createRechargeOrder_result:
26133 
  """
26134 
  Attributes:
26135 
   - success
26136 
   - ex
26137 
  """
26138 
 
26139 
  thrift_spec = (
26140 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26142 
  )
26143 
 
26144 
  def __init__(self, success=None, ex=None,):
26145 
    self.success = success
26146 
    self.ex = ex
26147 
 
26148 
  def read(self, iprot):
26149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26151 
      return
26152 
    iprot.readStructBegin()
26153 
    while True:
26154 
      (fname, ftype, fid) = iprot.readFieldBegin()
26155 
      if ftype == TType.STOP:
26156 
        break
26157 
      if fid == 0:
26158 
        if ftype == TType.STRUCT:
26159 
          self.success = RechargeOrder()
26160 
          self.success.read(iprot)
26161 
        else:
26162 
          iprot.skip(ftype)
26163 
      elif fid == 1:
26164 
        if ftype == TType.STRUCT:
26165 
          self.ex = TransactionServiceException()
26166 
          self.ex.read(iprot)
26167 
        else:
26168 
          iprot.skip(ftype)
26169 
      else:
26170 
        iprot.skip(ftype)
26171 
      iprot.readFieldEnd()
26172 
    iprot.readStructEnd()
26173 
 
26174 
  def write(self, oprot):
26175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26177 
      return
26178 
    oprot.writeStructBegin('createRechargeOrder_result')
26179 
    if self.success is not None:
26180 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26181 
      self.success.write(oprot)
26182 
      oprot.writeFieldEnd()
26183 
    if self.ex is not None:
26184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26185 
      self.ex.write(oprot)
26186 
      oprot.writeFieldEnd()
26187 
    oprot.writeFieldStop()
26188 
    oprot.writeStructEnd()
26189 
 
26190 
  def validate(self):
26191 
    return
26192 
 
26193 
 
26194 
  def __repr__(self):
26195 
    L = ['%s=%r' % (key, value)
26196 
      for key, value in self.__dict__.iteritems()]
26197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26198 
 
26199 
  def __eq__(self, other):
26200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26201 
 
26202 
  def __ne__(self, other):
26203 
    return not (self == other)
26204 
 
6031 rajveer 26205 
class getRechargeOrder_args:
26206 
  """
26207 
  Attributes:
26208 
   - rechargeRrderId
26209 
  """
26210 
 
26211 
  thrift_spec = (
26212 
    None, # 0
26213 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26214 
  )
26215 
 
26216 
  def __init__(self, rechargeRrderId=None,):
26217 
    self.rechargeRrderId = rechargeRrderId
26218 
 
26219 
  def read(self, iprot):
26220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26222 
      return
26223 
    iprot.readStructBegin()
26224 
    while True:
26225 
      (fname, ftype, fid) = iprot.readFieldBegin()
26226 
      if ftype == TType.STOP:
26227 
        break
26228 
      if fid == 1:
26229 
        if ftype == TType.I64:
26230 
          self.rechargeRrderId = iprot.readI64();
26231 
        else:
26232 
          iprot.skip(ftype)
26233 
      else:
26234 
        iprot.skip(ftype)
26235 
      iprot.readFieldEnd()
26236 
    iprot.readStructEnd()
26237 
 
26238 
  def write(self, oprot):
26239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26241 
      return
26242 
    oprot.writeStructBegin('getRechargeOrder_args')
26243 
    if self.rechargeRrderId is not None:
26244 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26245 
      oprot.writeI64(self.rechargeRrderId)
26246 
      oprot.writeFieldEnd()
26247 
    oprot.writeFieldStop()
26248 
    oprot.writeStructEnd()
26249 
 
26250 
  def validate(self):
26251 
    return
26252 
 
26253 
 
26254 
  def __repr__(self):
26255 
    L = ['%s=%r' % (key, value)
26256 
      for key, value in self.__dict__.iteritems()]
26257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26258 
 
26259 
  def __eq__(self, other):
26260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26261 
 
26262 
  def __ne__(self, other):
26263 
    return not (self == other)
26264 
 
26265 
class getRechargeOrder_result:
26266 
  """
26267 
  Attributes:
26268 
   - success
26269 
   - ex
26270 
  """
26271 
 
26272 
  thrift_spec = (
26273 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26275 
  )
26276 
 
26277 
  def __init__(self, success=None, ex=None,):
26278 
    self.success = success
26279 
    self.ex = ex
26280 
 
26281 
  def read(self, iprot):
26282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26284 
      return
26285 
    iprot.readStructBegin()
26286 
    while True:
26287 
      (fname, ftype, fid) = iprot.readFieldBegin()
26288 
      if ftype == TType.STOP:
26289 
        break
26290 
      if fid == 0:
26291 
        if ftype == TType.STRUCT:
26292 
          self.success = RechargeOrder()
26293 
          self.success.read(iprot)
26294 
        else:
26295 
          iprot.skip(ftype)
26296 
      elif fid == 1:
26297 
        if ftype == TType.STRUCT:
26298 
          self.ex = TransactionServiceException()
26299 
          self.ex.read(iprot)
26300 
        else:
26301 
          iprot.skip(ftype)
26302 
      else:
26303 
        iprot.skip(ftype)
26304 
      iprot.readFieldEnd()
26305 
    iprot.readStructEnd()
26306 
 
26307 
  def write(self, oprot):
26308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26310 
      return
26311 
    oprot.writeStructBegin('getRechargeOrder_result')
26312 
    if self.success is not None:
26313 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26314 
      self.success.write(oprot)
26315 
      oprot.writeFieldEnd()
26316 
    if self.ex is not None:
26317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26318 
      self.ex.write(oprot)
26319 
      oprot.writeFieldEnd()
26320 
    oprot.writeFieldStop()
26321 
    oprot.writeStructEnd()
26322 
 
26323 
  def validate(self):
26324 
    return
26325 
 
26326 
 
26327 
  def __repr__(self):
26328 
    L = ['%s=%r' % (key, value)
26329 
      for key, value in self.__dict__.iteritems()]
26330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26331 
 
26332 
  def __eq__(self, other):
26333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26334 
 
26335 
  def __ne__(self, other):
26336 
    return not (self == other)
26337 
 
26338 
class getRechargeOrders_args:
26339 
  """
26340 
  Attributes:
26341 
   - userId
26342 
  """
26343 
 
26344 
  thrift_spec = (
26345 
    None, # 0
26346 
    (1, TType.I64, 'userId', None, None, ), # 1
26347 
  )
26348 
 
26349 
  def __init__(self, userId=None,):
26350 
    self.userId = userId
26351 
 
26352 
  def read(self, iprot):
26353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26355 
      return
26356 
    iprot.readStructBegin()
26357 
    while True:
26358 
      (fname, ftype, fid) = iprot.readFieldBegin()
26359 
      if ftype == TType.STOP:
26360 
        break
26361 
      if fid == 1:
26362 
        if ftype == TType.I64:
26363 
          self.userId = iprot.readI64();
26364 
        else:
26365 
          iprot.skip(ftype)
26366 
      else:
26367 
        iprot.skip(ftype)
26368 
      iprot.readFieldEnd()
26369 
    iprot.readStructEnd()
26370 
 
26371 
  def write(self, oprot):
26372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26374 
      return
26375 
    oprot.writeStructBegin('getRechargeOrders_args')
26376 
    if self.userId is not None:
26377 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26378 
      oprot.writeI64(self.userId)
26379 
      oprot.writeFieldEnd()
26380 
    oprot.writeFieldStop()
26381 
    oprot.writeStructEnd()
26382 
 
26383 
  def validate(self):
26384 
    return
26385 
 
26386 
 
26387 
  def __repr__(self):
26388 
    L = ['%s=%r' % (key, value)
26389 
      for key, value in self.__dict__.iteritems()]
26390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26391 
 
26392 
  def __eq__(self, other):
26393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26394 
 
26395 
  def __ne__(self, other):
26396 
    return not (self == other)
26397 
 
26398 
class getRechargeOrders_result:
26399 
  """
26400 
  Attributes:
26401 
   - success
26402 
  """
26403 
 
26404 
  thrift_spec = (
26405 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26406 
  )
26407 
 
26408 
  def __init__(self, success=None,):
26409 
    self.success = success
26410 
 
26411 
  def read(self, iprot):
26412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26414 
      return
26415 
    iprot.readStructBegin()
26416 
    while True:
26417 
      (fname, ftype, fid) = iprot.readFieldBegin()
26418 
      if ftype == TType.STOP:
26419 
        break
26420 
      if fid == 0:
26421 
        if ftype == TType.LIST:
26422 
          self.success = []
26423 
          (_etype616, _size613) = iprot.readListBegin()
26424 
          for _i617 in xrange(_size613):
26425 
            _elem618 = RechargeOrder()
26426 
            _elem618.read(iprot)
26427 
            self.success.append(_elem618)
26428 
          iprot.readListEnd()
26429 
        else:
26430 
          iprot.skip(ftype)
26431 
      else:
26432 
        iprot.skip(ftype)
26433 
      iprot.readFieldEnd()
26434 
    iprot.readStructEnd()
26435 
 
26436 
  def write(self, oprot):
26437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26439 
      return
26440 
    oprot.writeStructBegin('getRechargeOrders_result')
26441 
    if self.success is not None:
26442 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26443 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26444 
      for iter619 in self.success:
26445 
        iter619.write(oprot)
26446 
      oprot.writeListEnd()
26447 
      oprot.writeFieldEnd()
26448 
    oprot.writeFieldStop()
26449 
    oprot.writeStructEnd()
26450 
 
26451 
  def validate(self):
26452 
    return
26453 
 
26454 
 
26455 
  def __repr__(self):
26456 
    L = ['%s=%r' % (key, value)
26457 
      for key, value in self.__dict__.iteritems()]
26458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26459 
 
26460 
  def __eq__(self, other):
26461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26462 
 
26463 
  def __ne__(self, other):
26464 
    return not (self == other)
26465 
 
6000 mandeep.dh 26466 
class updateRechargeOrderStatus_args:
26467 
  """
26468 
  Attributes:
26469 
   - rechargeOrderId
26470 
   - rechargeOrderStatus
26471 
  """
26472 
 
26473 
  thrift_spec = (
26474 
    None, # 0
26475 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26476 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26477 
  )
26478 
 
26479 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26480 
    self.rechargeOrderId = rechargeOrderId
26481 
    self.rechargeOrderStatus = rechargeOrderStatus
26482 
 
26483 
  def read(self, iprot):
26484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26486 
      return
26487 
    iprot.readStructBegin()
26488 
    while True:
26489 
      (fname, ftype, fid) = iprot.readFieldBegin()
26490 
      if ftype == TType.STOP:
26491 
        break
26492 
      if fid == 1:
26493 
        if ftype == TType.I64:
26494 
          self.rechargeOrderId = iprot.readI64();
26495 
        else:
26496 
          iprot.skip(ftype)
26497 
      elif fid == 2:
26498 
        if ftype == TType.I32:
26499 
          self.rechargeOrderStatus = iprot.readI32();
26500 
        else:
26501 
          iprot.skip(ftype)
26502 
      else:
26503 
        iprot.skip(ftype)
26504 
      iprot.readFieldEnd()
26505 
    iprot.readStructEnd()
26506 
 
26507 
  def write(self, oprot):
26508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26510 
      return
26511 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26512 
    if self.rechargeOrderId is not None:
26513 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26514 
      oprot.writeI64(self.rechargeOrderId)
26515 
      oprot.writeFieldEnd()
26516 
    if self.rechargeOrderStatus is not None:
26517 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26518 
      oprot.writeI32(self.rechargeOrderStatus)
26519 
      oprot.writeFieldEnd()
26520 
    oprot.writeFieldStop()
26521 
    oprot.writeStructEnd()
26522 
 
26523 
  def validate(self):
26524 
    return
26525 
 
26526 
 
26527 
  def __repr__(self):
26528 
    L = ['%s=%r' % (key, value)
26529 
      for key, value in self.__dict__.iteritems()]
26530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26531 
 
26532 
  def __eq__(self, other):
26533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26534 
 
26535 
  def __ne__(self, other):
26536 
    return not (self == other)
26537 
 
26538 
class updateRechargeOrderStatus_result:
26539 
  """
26540 
  Attributes:
6031 rajveer 26541 
   - success
6000 mandeep.dh 26542 
   - ex
26543 
  """
26544 
 
26545 
  thrift_spec = (
6031 rajveer 26546 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26548 
  )
26549 
 
6031 rajveer 26550 
  def __init__(self, success=None, ex=None,):
26551 
    self.success = success
6000 mandeep.dh 26552 
    self.ex = ex
26553 
 
26554 
  def read(self, iprot):
26555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26557 
      return
26558 
    iprot.readStructBegin()
26559 
    while True:
26560 
      (fname, ftype, fid) = iprot.readFieldBegin()
26561 
      if ftype == TType.STOP:
26562 
        break
6031 rajveer 26563 
      if fid == 0:
26564 
        if ftype == TType.BOOL:
26565 
          self.success = iprot.readBool();
26566 
        else:
26567 
          iprot.skip(ftype)
26568 
      elif fid == 1:
6000 mandeep.dh 26569 
        if ftype == TType.STRUCT:
26570 
          self.ex = TransactionServiceException()
26571 
          self.ex.read(iprot)
26572 
        else:
26573 
          iprot.skip(ftype)
26574 
      else:
26575 
        iprot.skip(ftype)
26576 
      iprot.readFieldEnd()
26577 
    iprot.readStructEnd()
26578 
 
26579 
  def write(self, oprot):
26580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26582 
      return
26583 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 26584 
    if self.success is not None:
26585 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26586 
      oprot.writeBool(self.success)
26587 
      oprot.writeFieldEnd()
6000 mandeep.dh 26588 
    if self.ex is not None:
26589 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26590 
      self.ex.write(oprot)
26591 
      oprot.writeFieldEnd()
26592 
    oprot.writeFieldStop()
26593 
    oprot.writeStructEnd()
26594 
 
26595 
  def validate(self):
26596 
    return
26597 
 
26598 
 
26599 
  def __repr__(self):
26600 
    L = ['%s=%r' % (key, value)
26601 
      for key, value in self.__dict__.iteritems()]
26602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26603 
 
26604 
  def __eq__(self, other):
26605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26606 
 
26607 
  def __ne__(self, other):
26608 
    return not (self == other)
26609 
 
26610 
class activateRechargeTxn_args:
26611 
  """
26612 
  Attributes:
6031 rajveer 26613 
   - rechargeOrderId
6000 mandeep.dh 26614 
  """
26615 
 
26616 
  thrift_spec = (
26617 
    None, # 0
6031 rajveer 26618 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 26619 
  )
26620 
 
6031 rajveer 26621 
  def __init__(self, rechargeOrderId=None,):
26622 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 26623 
 
26624 
  def read(self, iprot):
26625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26627 
      return
26628 
    iprot.readStructBegin()
26629 
    while True:
26630 
      (fname, ftype, fid) = iprot.readFieldBegin()
26631 
      if ftype == TType.STOP:
26632 
        break
26633 
      if fid == 1:
6031 rajveer 26634 
        if ftype == TType.I64:
26635 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 26636 
        else:
26637 
          iprot.skip(ftype)
26638 
      else:
26639 
        iprot.skip(ftype)
26640 
      iprot.readFieldEnd()
26641 
    iprot.readStructEnd()
26642 
 
26643 
  def write(self, oprot):
26644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26646 
      return
26647 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 26648 
    if self.rechargeOrderId is not None:
26649 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26650 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 26651 
      oprot.writeFieldEnd()
26652 
    oprot.writeFieldStop()
26653 
    oprot.writeStructEnd()
26654 
 
26655 
  def validate(self):
26656 
    return
26657 
 
26658 
 
26659 
  def __repr__(self):
26660 
    L = ['%s=%r' % (key, value)
26661 
      for key, value in self.__dict__.iteritems()]
26662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26663 
 
26664 
  def __eq__(self, other):
26665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26666 
 
26667 
  def __ne__(self, other):
26668 
    return not (self == other)
26669 
 
26670 
class activateRechargeTxn_result:
26671 
  """
26672 
  Attributes:
26673 
   - success
26674 
   - ex
26675 
  """
26676 
 
26677 
  thrift_spec = (
6031 rajveer 26678 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26679 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26680 
  )
26681 
 
26682 
  def __init__(self, success=None, ex=None,):
26683 
    self.success = success
26684 
    self.ex = ex
26685 
 
26686 
  def read(self, iprot):
26687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26689 
      return
26690 
    iprot.readStructBegin()
26691 
    while True:
26692 
      (fname, ftype, fid) = iprot.readFieldBegin()
26693 
      if ftype == TType.STOP:
26694 
        break
26695 
      if fid == 0:
6031 rajveer 26696 
        if ftype == TType.BOOL:
26697 
          self.success = iprot.readBool();
6000 mandeep.dh 26698 
        else:
26699 
          iprot.skip(ftype)
26700 
      elif fid == 1:
26701 
        if ftype == TType.STRUCT:
26702 
          self.ex = TransactionServiceException()
26703 
          self.ex.read(iprot)
26704 
        else:
26705 
          iprot.skip(ftype)
26706 
      else:
26707 
        iprot.skip(ftype)
26708 
      iprot.readFieldEnd()
26709 
    iprot.readStructEnd()
26710 
 
26711 
  def write(self, oprot):
26712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26714 
      return
26715 
    oprot.writeStructBegin('activateRechargeTxn_result')
26716 
    if self.success is not None:
6031 rajveer 26717 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26718 
      oprot.writeBool(self.success)
6000 mandeep.dh 26719 
      oprot.writeFieldEnd()
26720 
    if self.ex is not None:
26721 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26722 
      self.ex.write(oprot)
26723 
      oprot.writeFieldEnd()
26724 
    oprot.writeFieldStop()
26725 
    oprot.writeStructEnd()
26726 
 
26727 
  def validate(self):
26728 
    return
26729 
 
26730 
 
26731 
  def __repr__(self):
26732 
    L = ['%s=%r' % (key, value)
26733 
      for key, value in self.__dict__.iteritems()]
26734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26735 
 
26736 
  def __eq__(self, other):
26737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26738 
 
26739 
  def __ne__(self, other):
26740 
    return not (self == other)
26741 
 
6031 rajveer 26742 
class getUserWallet_args:
6000 mandeep.dh 26743 
  """
26744 
  Attributes:
6031 rajveer 26745 
   - userId
6000 mandeep.dh 26746 
  """
26747 
 
26748 
  thrift_spec = (
26749 
    None, # 0
6031 rajveer 26750 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 26751 
  )
26752 
 
6031 rajveer 26753 
  def __init__(self, userId=None,):
26754 
    self.userId = userId
6000 mandeep.dh 26755 
 
26756 
  def read(self, iprot):
26757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26759 
      return
26760 
    iprot.readStructBegin()
26761 
    while True:
26762 
      (fname, ftype, fid) = iprot.readFieldBegin()
26763 
      if ftype == TType.STOP:
26764 
        break
26765 
      if fid == 1:
26766 
        if ftype == TType.I64:
6031 rajveer 26767 
          self.userId = iprot.readI64();
6000 mandeep.dh 26768 
        else:
26769 
          iprot.skip(ftype)
26770 
      else:
26771 
        iprot.skip(ftype)
26772 
      iprot.readFieldEnd()
26773 
    iprot.readStructEnd()
26774 
 
26775 
  def write(self, oprot):
26776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26778 
      return
6031 rajveer 26779 
    oprot.writeStructBegin('getUserWallet_args')
26780 
    if self.userId is not None:
26781 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26782 
      oprot.writeI64(self.userId)
6000 mandeep.dh 26783 
      oprot.writeFieldEnd()
26784 
    oprot.writeFieldStop()
26785 
    oprot.writeStructEnd()
26786 
 
26787 
  def validate(self):
26788 
    return
26789 
 
26790 
 
26791 
  def __repr__(self):
26792 
    L = ['%s=%r' % (key, value)
26793 
      for key, value in self.__dict__.iteritems()]
26794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26795 
 
26796 
  def __eq__(self, other):
26797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26798 
 
26799 
  def __ne__(self, other):
26800 
    return not (self == other)
26801 
 
6031 rajveer 26802 
class getUserWallet_result:
6000 mandeep.dh 26803 
  """
26804 
  Attributes:
26805 
   - success
26806 
  """
26807 
 
26808 
  thrift_spec = (
6031 rajveer 26809 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 26810 
  )
26811 
 
26812 
  def __init__(self, success=None,):
26813 
    self.success = success
26814 
 
26815 
  def read(self, iprot):
26816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26818 
      return
26819 
    iprot.readStructBegin()
26820 
    while True:
26821 
      (fname, ftype, fid) = iprot.readFieldBegin()
26822 
      if ftype == TType.STOP:
26823 
        break
26824 
      if fid == 0:
6031 rajveer 26825 
        if ftype == TType.STRUCT:
26826 
          self.success = UserWallet()
26827 
          self.success.read(iprot)
6000 mandeep.dh 26828 
        else:
26829 
          iprot.skip(ftype)
26830 
      else:
26831 
        iprot.skip(ftype)
26832 
      iprot.readFieldEnd()
26833 
    iprot.readStructEnd()
26834 
 
26835 
  def write(self, oprot):
26836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26838 
      return
6031 rajveer 26839 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 26840 
    if self.success is not None:
6031 rajveer 26841 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26842 
      self.success.write(oprot)
6000 mandeep.dh 26843 
      oprot.writeFieldEnd()
26844 
    oprot.writeFieldStop()
26845 
    oprot.writeStructEnd()
26846 
 
26847 
  def validate(self):
26848 
    return
26849 
 
26850 
 
26851 
  def __repr__(self):
26852 
    L = ['%s=%r' % (key, value)
26853 
      for key, value in self.__dict__.iteritems()]
26854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26855 
 
26856 
  def __eq__(self, other):
26857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26858 
 
26859 
  def __ne__(self, other):
26860 
    return not (self == other)
26861 
 
6031 rajveer 26862 
class getUserWalletHistory_args:
6000 mandeep.dh 26863 
  """
26864 
  Attributes:
6031 rajveer 26865 
   - userId
6000 mandeep.dh 26866 
  """
26867 
 
26868 
  thrift_spec = (
26869 
    None, # 0
6031 rajveer 26870 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 26871 
  )
26872 
 
6031 rajveer 26873 
  def __init__(self, userId=None,):
26874 
    self.userId = userId
6000 mandeep.dh 26875 
 
26876 
  def read(self, iprot):
26877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26879 
      return
26880 
    iprot.readStructBegin()
26881 
    while True:
26882 
      (fname, ftype, fid) = iprot.readFieldBegin()
26883 
      if ftype == TType.STOP:
26884 
        break
26885 
      if fid == 1:
26886 
        if ftype == TType.I64:
6031 rajveer 26887 
          self.userId = iprot.readI64();
6000 mandeep.dh 26888 
        else:
26889 
          iprot.skip(ftype)
26890 
      else:
26891 
        iprot.skip(ftype)
26892 
      iprot.readFieldEnd()
26893 
    iprot.readStructEnd()
26894 
 
26895 
  def write(self, oprot):
26896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26898 
      return
6031 rajveer 26899 
    oprot.writeStructBegin('getUserWalletHistory_args')
26900 
    if self.userId is not None:
26901 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26902 
      oprot.writeI64(self.userId)
6000 mandeep.dh 26903 
      oprot.writeFieldEnd()
26904 
    oprot.writeFieldStop()
26905 
    oprot.writeStructEnd()
26906 
 
26907 
  def validate(self):
26908 
    return
26909 
 
26910 
 
26911 
  def __repr__(self):
26912 
    L = ['%s=%r' % (key, value)
26913 
      for key, value in self.__dict__.iteritems()]
26914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26915 
 
26916 
  def __eq__(self, other):
26917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26918 
 
26919 
  def __ne__(self, other):
26920 
    return not (self == other)
26921 
 
6031 rajveer 26922 
class getUserWalletHistory_result:
6000 mandeep.dh 26923 
  """
26924 
  Attributes:
26925 
   - success
26926 
  """
26927 
 
26928 
  thrift_spec = (
6031 rajveer 26929 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 26930 
  )
26931 
 
26932 
  def __init__(self, success=None,):
26933 
    self.success = success
26934 
 
26935 
  def read(self, iprot):
26936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26938 
      return
26939 
    iprot.readStructBegin()
26940 
    while True:
26941 
      (fname, ftype, fid) = iprot.readFieldBegin()
26942 
      if ftype == TType.STOP:
26943 
        break
26944 
      if fid == 0:
26945 
        if ftype == TType.LIST:
26946 
          self.success = []
6031 rajveer 26947 
          (_etype623, _size620) = iprot.readListBegin()
26948 
          for _i624 in xrange(_size620):
26949 
            _elem625 = UserWalletHistory()
26950 
            _elem625.read(iprot)
26951 
            self.success.append(_elem625)
6000 mandeep.dh 26952 
          iprot.readListEnd()
26953 
        else:
26954 
          iprot.skip(ftype)
26955 
      else:
26956 
        iprot.skip(ftype)
26957 
      iprot.readFieldEnd()
26958 
    iprot.readStructEnd()
26959 
 
26960 
  def write(self, oprot):
26961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26963 
      return
6031 rajveer 26964 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 26965 
    if self.success is not None:
26966 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26967 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 26968 
      for iter626 in self.success:
26969 
        iter626.write(oprot)
6000 mandeep.dh 26970 
      oprot.writeListEnd()
26971 
      oprot.writeFieldEnd()
26972 
    oprot.writeFieldStop()
26973 
    oprot.writeStructEnd()
26974 
 
26975 
  def validate(self):
26976 
    return
26977 
 
26978 
 
26979 
  def __repr__(self):
26980 
    L = ['%s=%r' % (key, value)
26981 
      for key, value in self.__dict__.iteritems()]
26982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26983 
 
26984 
  def __eq__(self, other):
26985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26986 
 
26987 
  def __ne__(self, other):
26988 
    return not (self == other)
6048 rajveer 26989 
 
26990 
class getServiceProviders_args:
26991 
  """
26992 
  Attributes:
26993 
   - rechargeType
26994 
  """
26995 
 
26996 
  thrift_spec = (
26997 
    None, # 0
26998 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
26999 
  )
27000 
 
27001 
  def __init__(self, rechargeType=None,):
27002 
    self.rechargeType = rechargeType
27003 
 
27004 
  def read(self, iprot):
27005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27007 
      return
27008 
    iprot.readStructBegin()
27009 
    while True:
27010 
      (fname, ftype, fid) = iprot.readFieldBegin()
27011 
      if ftype == TType.STOP:
27012 
        break
27013 
      if fid == 1:
27014 
        if ftype == TType.I32:
27015 
          self.rechargeType = iprot.readI32();
27016 
        else:
27017 
          iprot.skip(ftype)
27018 
      else:
27019 
        iprot.skip(ftype)
27020 
      iprot.readFieldEnd()
27021 
    iprot.readStructEnd()
27022 
 
27023 
  def write(self, oprot):
27024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27026 
      return
27027 
    oprot.writeStructBegin('getServiceProviders_args')
27028 
    if self.rechargeType is not None:
27029 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27030 
      oprot.writeI32(self.rechargeType)
27031 
      oprot.writeFieldEnd()
27032 
    oprot.writeFieldStop()
27033 
    oprot.writeStructEnd()
27034 
 
27035 
  def validate(self):
27036 
    return
27037 
 
27038 
 
27039 
  def __repr__(self):
27040 
    L = ['%s=%r' % (key, value)
27041 
      for key, value in self.__dict__.iteritems()]
27042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27043 
 
27044 
  def __eq__(self, other):
27045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27046 
 
27047 
  def __ne__(self, other):
27048 
    return not (self == other)
27049 
 
27050 
class getServiceProviders_result:
27051 
  """
27052 
  Attributes:
27053 
   - success
27054 
  """
27055 
 
27056 
  thrift_spec = (
27057 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27058 
  )
27059 
 
27060 
  def __init__(self, success=None,):
27061 
    self.success = success
27062 
 
27063 
  def read(self, iprot):
27064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27066 
      return
27067 
    iprot.readStructBegin()
27068 
    while True:
27069 
      (fname, ftype, fid) = iprot.readFieldBegin()
27070 
      if ftype == TType.STOP:
27071 
        break
27072 
      if fid == 0:
27073 
        if ftype == TType.MAP:
27074 
          self.success = {}
27075 
          (_ktype628, _vtype629, _size627 ) = iprot.readMapBegin()
27076 
          for _i631 in xrange(_size627):
27077 
            _key632 = iprot.readI64();
27078 
            _val633 = iprot.readString();
27079 
            self.success[_key632] = _val633
27080 
          iprot.readMapEnd()
27081 
        else:
27082 
          iprot.skip(ftype)
27083 
      else:
27084 
        iprot.skip(ftype)
27085 
      iprot.readFieldEnd()
27086 
    iprot.readStructEnd()
27087 
 
27088 
  def write(self, oprot):
27089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27091 
      return
27092 
    oprot.writeStructBegin('getServiceProviders_result')
27093 
    if self.success is not None:
27094 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27095 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
27096 
      for kiter634,viter635 in self.success.items():
27097 
        oprot.writeI64(kiter634)
27098 
        oprot.writeString(viter635)
27099 
      oprot.writeMapEnd()
27100 
      oprot.writeFieldEnd()
27101 
    oprot.writeFieldStop()
27102 
    oprot.writeStructEnd()
27103 
 
27104 
  def validate(self):
27105 
    return
27106 
 
27107 
 
27108 
  def __repr__(self):
27109 
    L = ['%s=%r' % (key, value)
27110 
      for key, value in self.__dict__.iteritems()]
27111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27112 
 
27113 
  def __eq__(self, other):
27114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27115 
 
27116 
  def __ne__(self, other):
27117 
    return not (self == other)
27118 
 
27119 
class getServiceProviderForDevice_args:
27120 
  """
27121 
  Attributes:
6049 rajveer 27122 
   - rechargeType
6048 rajveer 27123 
   - deviceNumber
27124 
  """
27125 
 
27126 
  thrift_spec = (
27127 
    None, # 0
6049 rajveer 27128 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27129 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27130 
  )
27131 
 
6049 rajveer 27132 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27133 
    self.rechargeType = rechargeType
6048 rajveer 27134 
    self.deviceNumber = deviceNumber
27135 
 
27136 
  def read(self, iprot):
27137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27139 
      return
27140 
    iprot.readStructBegin()
27141 
    while True:
27142 
      (fname, ftype, fid) = iprot.readFieldBegin()
27143 
      if ftype == TType.STOP:
27144 
        break
27145 
      if fid == 1:
6049 rajveer 27146 
        if ftype == TType.I32:
27147 
          self.rechargeType = iprot.readI32();
27148 
        else:
27149 
          iprot.skip(ftype)
27150 
      elif fid == 2:
6048 rajveer 27151 
        if ftype == TType.STRING:
27152 
          self.deviceNumber = iprot.readString();
27153 
        else:
27154 
          iprot.skip(ftype)
27155 
      else:
27156 
        iprot.skip(ftype)
27157 
      iprot.readFieldEnd()
27158 
    iprot.readStructEnd()
27159 
 
27160 
  def write(self, oprot):
27161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27163 
      return
27164 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27165 
    if self.rechargeType is not None:
27166 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27167 
      oprot.writeI32(self.rechargeType)
27168 
      oprot.writeFieldEnd()
6048 rajveer 27169 
    if self.deviceNumber is not None:
6049 rajveer 27170 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27171 
      oprot.writeString(self.deviceNumber)
27172 
      oprot.writeFieldEnd()
27173 
    oprot.writeFieldStop()
27174 
    oprot.writeStructEnd()
27175 
 
27176 
  def validate(self):
27177 
    return
27178 
 
27179 
 
27180 
  def __repr__(self):
27181 
    L = ['%s=%r' % (key, value)
27182 
      for key, value in self.__dict__.iteritems()]
27183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27184 
 
27185 
  def __eq__(self, other):
27186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27187 
 
27188 
  def __ne__(self, other):
27189 
    return not (self == other)
27190 
 
27191 
class getServiceProviderForDevice_result:
27192 
  """
27193 
  Attributes:
27194 
   - success
27195 
  """
27196 
 
27197 
  thrift_spec = (
27198 
    (0, TType.I64, 'success', None, None, ), # 0
27199 
  )
27200 
 
27201 
  def __init__(self, success=None,):
27202 
    self.success = success
27203 
 
27204 
  def read(self, iprot):
27205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27207 
      return
27208 
    iprot.readStructBegin()
27209 
    while True:
27210 
      (fname, ftype, fid) = iprot.readFieldBegin()
27211 
      if ftype == TType.STOP:
27212 
        break
27213 
      if fid == 0:
27214 
        if ftype == TType.I64:
27215 
          self.success = iprot.readI64();
27216 
        else:
27217 
          iprot.skip(ftype)
27218 
      else:
27219 
        iprot.skip(ftype)
27220 
      iprot.readFieldEnd()
27221 
    iprot.readStructEnd()
27222 
 
27223 
  def write(self, oprot):
27224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27226 
      return
27227 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27228 
    if self.success is not None:
27229 
      oprot.writeFieldBegin('success', TType.I64, 0)
27230 
      oprot.writeI64(self.success)
27231 
      oprot.writeFieldEnd()
27232 
    oprot.writeFieldStop()
27233 
    oprot.writeStructEnd()
27234 
 
27235 
  def validate(self):
27236 
    return
27237 
 
27238 
 
27239 
  def __repr__(self):
27240 
    L = ['%s=%r' % (key, value)
27241 
      for key, value in self.__dict__.iteritems()]
27242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27243 
 
27244 
  def __eq__(self, other):
27245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27246 
 
27247 
  def __ne__(self, other):
27248 
    return not (self == other)