Subversion Repositories SmartDukaan

Rev

Rev 7026 | Rev 7075 | 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 
 
6756 amar.kumar 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
6756 amar.kumar 366 
     - serialNumber
367 
     - itemNumber
4579 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 372 
    """
373 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 374 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 375 
 
376 
    Parameters:
377 
     - warehouseId
378 
     - providerId
379 
     - cod
4910 phani.kuma 380 
     - orderIds
4410 rajveer 381 
    """
382 
    pass
383 
 
5713 rajveer 384 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 385 
    """
386 
    Parameters:
387 
     - providerId
388 
     - orderIds
5713 rajveer 389 
     - awbs
5676 rajveer 390 
    """
391 
    pass
392 
 
4910 phani.kuma 393 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 394 
    """
4910 phani.kuma 395 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
396 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 397 
 
3064 chandransh 398 
    Parameters:
759 chandransh 399 
     - providerId
4910 phani.kuma 400 
     - pickupDetails
759 chandransh 401 
    """
402 
    pass
403 
 
4910 phani.kuma 404 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 405 
    """
406 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 407 
 
1113 chandransh 408 
    Parameters:
409 
     - providerId
410 
    """
411 
    pass
412 
 
1132 chandransh 413 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
414 
    """
415 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
416 
    the name of the receiver.
417 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 418 
 
1132 chandransh 419 
    Parameters:
420 
     - providerId
421 
     - deliveredOrders
422 
    """
423 
    pass
424 
 
4910 phani.kuma 425 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 426 
    """
4910 phani.kuma 427 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 428 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 429 
 
1135 chandransh 430 
    Parameters:
431 
     - providerId
432 
     - returnedOrders
433 
    """
434 
    pass
435 
 
4910 phani.kuma 436 
  def getRTOrders(self, providerId):
437 
    """
438 
    Returns a list of orders that were returned by courier.
439 
 
440 
    Parameters:
441 
     - providerId
442 
    """
443 
    pass
444 
 
1246 chandransh 445 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
446 
    """
447 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 448 
 
1246 chandransh 449 
    Parameters:
450 
     - providerId
451 
     - undeliveredOrders
452 
    """
453 
    pass
454 
 
4910 phani.kuma 455 
  def getNonDeliveredOrdersbyCourier(self, providerId):
456 
    """
457 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
458 
 
459 
    Parameters:
460 
     - providerId
461 
    """
462 
    pass
463 
 
464 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
465 
    """
466 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
467 
 
468 
    Parameters:
469 
     - providerId
470 
     - local_connected_orders
471 
    """
472 
    pass
473 
 
474 
  def getOrdersNotLocalConnected(self, providerId):
475 
    """
476 
    Returns a list of orders that were picked up or shipped but pending local connection.
477 
 
478 
    Parameters:
479 
     - providerId
480 
    """
481 
    pass
482 
 
483 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
484 
    """
485 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
486 
 
487 
    Parameters:
488 
     - providerId
489 
     - destination_city_reached_orders
490 
    """
491 
    pass
492 
 
493 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
494 
    """
495 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
496 
 
497 
    Parameters:
498 
     - providerId
499 
     - first_atdl_orders
500 
    """
501 
    pass
502 
 
1408 ankur.sing 503 
  def getUndeliveredOrders(self, providerId, warehouseId):
504 
    """
505 
    Returns the list of orders whose delivery time has passed but have not been
506 
    delivered yet for the given provider and warehouse. To get a complete list of
507 
    undelivered orders, pass them as -1.
508 
    Returns an empty list if no such orders exist.
3431 rajveer 509 
 
1408 ankur.sing 510 
    Parameters:
511 
     - providerId
512 
     - warehouseId
513 
    """
514 
    pass
515 
 
4783 phani.kuma 516 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
517 
    """
518 
    Returns the list of orders whose expected delivery date has passed but have not been
519 
    delivered yet.
520 
    Returns an empty list if no such orders exist.
521 
    """
522 
    pass
523 
 
2536 chandransh 524 
  def toggleDOAFlag(self, orderId):
525 
    """
526 
    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.
527 
    Returns the final flag status.
528 
    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 529 
 
2536 chandransh 530 
    Parameters:
531 
     - orderId
532 
    """
533 
    pass
1886 ankur.sing 534 
 
4712 rajveer 535 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
536 
    """
537 
    Parameters:
538 
     - orderId
539 
     - deliveryTimestamp
540 
     - receiver
541 
    """
542 
    pass
543 
 
5553 rajveer 544 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
545 
    """
546 
    Parameters:
547 
     - orderId
548 
     - deliveryTimestamp
549 
    """
550 
    pass
551 
 
4454 rajveer 552 
  def markOrderDoaRequestReceived(self, orderId):
553 
    """
554 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
555 
 
556 
    Parameters:
557 
     - orderId
558 
    """
559 
    pass
560 
 
561 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
562 
    """
563 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
564 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
565 
 
566 
    Parameters:
567 
     - orderId
568 
     - isAuthorized
569 
    """
570 
    pass
571 
 
4488 rajveer 572 
  def markOrderReturnRequestReceived(self, orderId):
573 
    """
574 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
575 
 
576 
    Parameters:
577 
     - orderId
578 
    """
579 
    pass
580 
 
581 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
582 
    """
583 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
584 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
585 
 
586 
    Parameters:
587 
     - orderId
588 
     - isAuthorized
589 
    """
590 
    pass
591 
 
4579 rajveer 592 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 593 
    """
594 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 595 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
596 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 597 
    For any other status, it returns false.
598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2536 chandransh 600 
    Parameters:
601 
     - orderId
4579 rajveer 602 
     - providerId
2536 chandransh 603 
    """
604 
    pass
605 
 
4602 rajveer 606 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 607 
    """
4452 rajveer 608 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 609 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
610 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
611 
    	3. Returns true
2591 chandransh 612 
    If the order is in any other status, it returns false.
2536 chandransh 613 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 614 
 
2536 chandransh 615 
    Parameters:
616 
     - orderId
617 
     - pickupNumber
4602 rajveer 618 
     - providerId
2536 chandransh 619 
    """
620 
    pass
621 
 
2764 chandransh 622 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
623 
    """
624 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 625 
 
2764 chandransh 626 
    Parameters:
627 
     - providerId
628 
     - pickupDetails
629 
    """
630 
    pass
631 
 
4910 phani.kuma 632 
  def getDoasNotPickedUp(self, providerId):
633 
    """
634 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
635 
 
636 
    Parameters:
637 
     - providerId
638 
    """
639 
    pass
640 
 
4741 phani.kuma 641 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
642 
    """
643 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
644 
 
645 
    Parameters:
646 
     - providerId
647 
     - pickupDetails
648 
    """
649 
    pass
650 
 
4910 phani.kuma 651 
  def getReturnOrdersNotPickedUp(self, providerId):
652 
    """
653 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
654 
 
655 
    Parameters:
656 
     - providerId
657 
    """
658 
    pass
659 
 
4479 rajveer 660 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 661 
    """
4452 rajveer 662 
    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 663 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 664 
    If the order is in any other state, it returns false.
665 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 666 
 
2591 chandransh 667 
    Parameters:
668 
     - orderId
4479 rajveer 669 
     - receiveCondition
2591 chandransh 670 
    """
671 
    pass
2536 chandransh 672 
 
2591 chandransh 673 
  def validateDoa(self, orderId, isValid):
674 
    """
4452 rajveer 675 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 676 
    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 677 
    If the order is in any other state, it returns false.
678 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 679 
 
2591 chandransh 680 
    Parameters:
681 
     - orderId
682 
     - isValid
683 
    """
684 
    pass
685 
 
4495 rajveer 686 
  def validateReturnProduct(self, orderId, isUsable):
687 
    """
688 
    Parameters:
689 
     - orderId
690 
     - isUsable
691 
    """
692 
    pass
693 
 
2616 chandransh 694 
  def reshipOrder(self, orderId):
695 
    """
4484 rajveer 696 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 697 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 698 
    	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 699 
 
700 
    If the order is in DOA_CERT_VALID state, it does the following:
701 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
702 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 703 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 704 
 
2616 chandransh 705 
    Returns the id of the newly created order.
3431 rajveer 706 
 
2616 chandransh 707 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 708 
 
2616 chandransh 709 
    Parameters:
710 
     - orderId
711 
    """
712 
    pass
2591 chandransh 713 
 
3226 chandransh 714 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 715 
    """
4484 rajveer 716 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 717 
    	1. Creates a refund request for batch processing.
718 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 719 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 720 
 
2616 chandransh 721 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
722 
    	1. Creates a refund request for batch processing.
3226 chandransh 723 
    	2. Cancels the reservation of the item in the warehouse.
724 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 725 
 
3226 chandransh 726 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
727 
    	1. Cancels the reservation of the item in the warehouse.
728 
    	2. Marks the current order as CANCELED.
729 
 
730 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
731 
 
2616 chandransh 732 
    Returns True if it is successful, False otherwise.
3431 rajveer 733 
 
2616 chandransh 734 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 735 
 
2616 chandransh 736 
    Parameters:
737 
     - orderId
3226 chandransh 738 
     - refundedBy
739 
     - reason
2616 chandransh 740 
    """
741 
    pass
742 
 
2690 chandransh 743 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
744 
    """
745 
    Get all return orders created between the from and to dates for the given warehouse.
746 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 747 
 
2690 chandransh 748 
    Parameters:
749 
     - warehouseId
750 
     - fromDate
751 
     - toDate
752 
    """
753 
    pass
2616 chandransh 754 
 
5481 phani.kuma 755 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
756 
    """
757 
    Get all return orders created between the from and to dates.
758 
 
759 
    Parameters:
760 
     - onlyNotProcessed
761 
     - fromDate
762 
     - toDate
763 
    """
764 
    pass
765 
 
2700 chandransh 766 
  def getReturnOrder(self, id):
767 
    """
768 
    Returns the ReturnOrder corresponding to the given id.
769 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 770 
 
2700 chandransh 771 
    Parameters:
772 
     - id
773 
    """
774 
    pass
775 
 
2690 chandransh 776 
  def processReturn(self, returnOrderId):
777 
    """
778 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 779 
 
2690 chandransh 780 
    Parameters:
781 
     - returnOrderId
782 
    """
783 
    pass
784 
 
3451 chandransh 785 
  def updateWeight(self, orderId, weight):
786 
    """
787 
    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 788 
 
3451 chandransh 789 
    Parameters:
790 
     - orderId
791 
     - weight
792 
    """
793 
    pass
794 
 
3469 chandransh 795 
  def changeItem(self, orderId, itemId):
796 
    """
797 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
798 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 799 
 
3469 chandransh 800 
    Parameters:
801 
     - orderId
802 
     - itemId
803 
    """
804 
    pass
805 
 
806 
  def shiftToWarehouse(self, orderId, warehouseId):
807 
    """
808 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
809 
 
810 
    Parameters:
811 
     - orderId
812 
     - warehouseId
813 
    """
814 
    pass
815 
 
4647 rajveer 816 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 817 
    """
818 
    Adds the given delay reason to the given order.
3986 chandransh 819 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 820 
    Raises an exception if no order with the given id can be found.
3469 chandransh 821 
 
3553 chandransh 822 
    Parameters:
823 
     - orderId
824 
     - delayReason
3986 chandransh 825 
     - furtherDelay
4647 rajveer 826 
     - delayReasonText
3553 chandransh 827 
    """
828 
    pass
829 
 
3956 chandransh 830 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
831 
    """
832 
    Marks the COD orders with given AWB nos. as having been processed.
833 
    Updates the captured amount for the corresponding payment.
3553 chandransh 834 
 
3956 chandransh 835 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
836 
    1. There is no order corresponding to an AWB number.
837 
    2. The captured amount for a payment exceeds the total payment.
838 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
839 
 
840 
    Parameters:
841 
     - collectedAmountMap
842 
     - xferBy
843 
     - xferTxnId
844 
     - xferDate
845 
    """
846 
    pass
847 
 
4008 mandeep.dh 848 
  def getTransactionsRequiringExtraProcessing(self, category):
849 
    """
4065 mandeep.dh 850 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 851 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 852 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 853 
 
4008 mandeep.dh 854 
    Parameters:
855 
     - category
856 
    """
857 
    pass
858 
 
859 
  def markTransactionAsProcessed(self, transactionId, category):
860 
    """
861 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 862 
    It essentially deletes the transaction id record for a particular
863 
    processing type category (if present) from DB.
864 
    This is currently used by CRM application.
4008 mandeep.dh 865 
 
866 
    Parameters:
867 
     - transactionId
868 
     - category
869 
    """
870 
    pass
871 
 
4018 chandransh 872 
  def getItemWiseRiskyOrdersCount(self, ):
873 
    """
874 
    Returns a map containing the number of risky orders keyed by item id. A risky order
875 
    is defined as one whose shipping date is about to expire.
876 
    """
877 
    pass
4008 mandeep.dh 878 
 
4295 varun.gupt 879 
  def getOrdersForItemIds(self, itemIds):
880 
    """
881 
    Returns a list of all orders which have items with given id
882 
 
883 
    Parameters:
884 
     - itemIds
885 
    """
886 
    pass
887 
 
4247 rajveer 888 
  def markOrderCancellationRequestReceived(self, orderId):
889 
    """
890 
    Mark order as cancellation request received. If customer sends request of cancellation of
891 
    a particular order, this method will be called. It will just change status of the order
892 
    depending on its current status. It also records the previous status, so that we can move
893 
    back to that status if cancellation request is denied.
4018 chandransh 894 
 
4247 rajveer 895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
900 
  def markOrderCancellationRequestConfirmed(self, orderId):
901 
    """
902 
    If we decide to to cancel order, CRM will call this method to move the status of order to
903 
    cancellation request confirmed. After this OM will be able to cancel the order.
904 
 
905 
    Parameters:
906 
     - orderId
907 
    """
908 
    pass
909 
 
910 
  def markOrderCancellationRequestDenied(self, orderId):
911 
    """
912 
    If we decide to not to cancel order, we will move the order ro previous status.
913 
 
914 
    Parameters:
915 
     - orderId
916 
    """
917 
    pass
918 
 
4258 rajveer 919 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 920 
    """
4258 rajveer 921 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
922 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 923 
 
924 
    Parameters:
4258 rajveer 925 
     - transactionId
4247 rajveer 926 
    """
927 
    pass
928 
 
4259 anupam.sin 929 
  def refundTransaction(self, transactionId, refundedBy, reason):
930 
    """
931 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
932 
    need to be cancelled
4247 rajveer 933 
 
4259 anupam.sin 934 
    Parameters:
935 
     - transactionId
936 
     - refundedBy
937 
     - reason
938 
    """
939 
    pass
940 
 
4324 mandeep.dh 941 
  def updateShipmentAddress(self, orderId, addressId):
942 
    """
943 
    Updates shipment address of an order. Delivery and shipping date estimates
944 
    etc. are also updated here.
945 
 
946 
    Throws TransactionServiceException in case address change is not
947 
    possible due to certain reasons such as new pincode in address is
948 
    not serviceable etc.
949 
 
950 
    Parameters:
951 
     - orderId
952 
     - addressId
953 
    """
954 
    pass
955 
 
4285 rajveer 956 
  def acceptOrdersForItemId(self, itemId, inventory):
957 
    """
958 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
959 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 960 
 
4285 rajveer 961 
    Parameters:
962 
     - itemId
963 
     - inventory
964 
    """
965 
    pass
966 
 
4369 rajveer 967 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 968 
    """
969 
    Parameters:
970 
     - vendorId
971 
     - itemId
972 
     - quantity
973 
     - estimate
4369 rajveer 974 
     - isReminder
4303 rajveer 975 
    """
976 
    pass
4285 rajveer 977 
 
4369 rajveer 978 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 979 
    """
980 
    Parameters:
981 
     - vendorId
982 
     - itemId
983 
     - quantity
984 
     - estimate
4369 rajveer 985 
     - isReminder
4303 rajveer 986 
    """
987 
    pass
988 
 
4369 rajveer 989 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 990 
    """
991 
    Parameters:
992 
     - vendorId
993 
     - itemId
994 
     - quantity
995 
     - estimate
4369 rajveer 996 
     - isReminder
4303 rajveer 997 
    """
998 
    pass
999 
 
4369 rajveer 1000 
  def markOrdersAsTimeout(self, vendorId):
1001 
    """
1002 
    Parameters:
1003 
     - vendorId
1004 
    """
1005 
    pass
4303 rajveer 1006 
 
4662 rajveer 1007 
  def markOrderAsLostInTransit(self, orderId):
1008 
    """
1009 
    Mark order as LOST_IN_TRANSIT
1010 
 
1011 
    Parameters:
1012 
     - orderId
1013 
    """
1014 
    pass
1015 
 
4386 anupam.sin 1016 
  def getOrderForAwb(self, awb):
1017 
    """
1018 
    Returns the order corresponding to an AWB number
4369 rajveer 1019 
 
4386 anupam.sin 1020 
    Parameters:
1021 
     - awb
1022 
    """
1023 
    pass
1024 
 
4910 phani.kuma 1025 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1026 
    """
4910 phani.kuma 1027 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1028 
 
4506 phani.kuma 1029 
    Parameters:
1030 
     - logistics_provider_id
4910 phani.kuma 1031 
     - order_status_list
4506 phani.kuma 1032 
    """
1033 
    pass
1034 
 
4600 varun.gupt 1035 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1036 
    """
1037 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1038 
 
4600 varun.gupt 1039 
    Parameters:
1040 
     - vendorId
1041 
     - billingDateFrom
1042 
     - billingDateTo
1043 
    """
1044 
    pass
1045 
 
4607 rajveer 1046 
  def getSlippedSippingDateOrders(self, ):
1047 
    pass
1048 
 
4709 rajveer 1049 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1050 
    """
1051 
    Parameters:
1052 
     - cancelDateFrom
1053 
     - cancelDateTo
1054 
    """
1055 
    pass
1056 
 
4600 varun.gupt 1057 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1058 
    """
1059 
    Parameters:
1060 
     - mapAWBAndAmount
1061 
    """
1062 
    pass
1063 
 
4905 varun.gupt 1064 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1065 
    """
1066 
    Parameters:
1067 
     - settlementDate
1068 
     - paymentGatewayId
4905 varun.gupt 1069 
     - referenceId
4600 varun.gupt 1070 
     - serviceTax
1071 
     - otherCharges
1072 
     - netCollection
1073 
    """
1074 
    pass
1075 
 
1076 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1077 
    """
1078 
    Parameters:
1079 
     - settlementId
1080 
     - settlementDate
1081 
     - transactionDateFrom
1082 
     - transactionDateTo
1083 
     - amount
1084 
    """
1085 
    pass
1086 
 
5386 phani.kuma 1087 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1088 
    """
1089 
    Parameters:
5189 varun.gupt 1090 
     - referenceId
1091 
     - isRefund
4600 varun.gupt 1092 
    """
1093 
    pass
1094 
 
5386 phani.kuma 1095 
  def getSettlementForCod(self, orderId, isRefund):
1096 
    """
1097 
    Parameters:
1098 
     - orderId
1099 
     - isRefund
1100 
    """
1101 
    pass
1102 
 
4600 varun.gupt 1103 
  def getEBSSettlementSummaries(self, ):
1104 
    pass
1105 
 
1106 
  def markEBSSettlementUploaded(self, settlementId):
1107 
    """
1108 
    Parameters:
1109 
     - settlementId
1110 
    """
1111 
    pass
1112 
 
1113 
  def getEBSSettlementDate(self, settlementId):
1114 
    """
1115 
    Parameters:
1116 
     - settlementId
1117 
    """
1118 
    pass
1119 
 
4715 varun.gupt 1120 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1121 
    """
1122 
    Parameters:
1123 
     - settlementDateFrom
1124 
     - settlementDateTo
1125 
     - isRefund
1126 
    """
1127 
    pass
4600 varun.gupt 1128 
 
4715 varun.gupt 1129 
  def getReshippedOrderIds(self, orderIds):
1130 
    """
1131 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1132 
 
1133 
    Parameters:
1134 
     - orderIds
1135 
    """
1136 
    pass
1137 
 
5481 phani.kuma 1138 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1139 
    """
1140 
    Parameters:
1141 
     - vendorId
5481 phani.kuma 1142 
     - onlyVendorNotPaid
1143 
     - billingDateFrom
1144 
     - billingDateTo
4875 varun.gupt 1145 
    """
1146 
    pass
4757 mandeep.dh 1147 
 
5031 varun.gupt 1148 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1149 
    """
1150 
    Parameters:
1151 
     - startDate
1152 
     - endDate
1153 
    """
1154 
    pass
4875 varun.gupt 1155 
 
5067 varun.gupt 1156 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1157 
    """
1158 
    Parameters:
1159 
     - status
1160 
     - startDatetime
1161 
     - endDatetime
1162 
    """
1163 
    pass
5031 varun.gupt 1164 
 
5348 anupam.sin 1165 
  def updateCODAgent(self, agent, orderId):
1166 
    """
1167 
    Updates the agent who handled the COD verification call
1168 
 
1169 
    Parameters:
1170 
     - agent
1171 
     - orderId
1172 
    """
1173 
    pass
1174 
 
5099 varun.gupt 1175 
  def updateOrderAsPaidToVendor(self, orderId):
1176 
    """
1177 
    Parameters:
1178 
     - orderId
1179 
    """
1180 
    pass
5067 varun.gupt 1181 
 
5386 phani.kuma 1182 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1183 
    """
1184 
    Parameters:
1185 
     - orderId
1186 
    """
1187 
    pass
1188 
 
5208 varun.gupt 1189 
  def getRefundedOrdersMarkedPaid(self, ):
1190 
    pass
5099 varun.gupt 1191 
 
5447 anupam.sin 1192 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1193 
    """
1194 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1195 
 
5447 anupam.sin 1196 
 
1197 
    Parameters:
1198 
     - minOrderId
1199 
     - maxOrderId
1200 
    """
1201 
    pass
1202 
 
5527 anupam.sin 1203 
  def getAllAttributesForOrderId(self, orderId):
1204 
    """
1205 
    gets all attributes for a given orderId
5447 anupam.sin 1206 
 
5527 anupam.sin 1207 
    Parameters:
1208 
     - orderId
1209 
    """
1210 
    pass
1211 
 
5676 rajveer 1212 
  def setOrderAttributes(self, orderId, attributes):
1213 
    """
1214 
    sets attributes for an order
1215 
 
1216 
    Parameters:
1217 
     - orderId
1218 
     - attributes
1219 
    """
1220 
    pass
1221 
 
5527 anupam.sin 1222 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1223 
    """
1224 
    sets attributes for all orders in a transaction
1225 
 
1226 
    Parameters:
1227 
     - transactionId
1228 
     - attribute
1229 
    """
1230 
    pass
1231 
 
5553 rajveer 1232 
  def getReceivePendingOrders(self, storeId):
1233 
    """
1234 
    Parameters:
1235 
     - storeId
1236 
    """
1237 
    pass
5527 anupam.sin 1238 
 
5553 rajveer 1239 
  def getReceivedAtStoreOrders(self, storeId):
1240 
    """
1241 
    Parameters:
1242 
     - storeId
1243 
    """
1244 
    pass
1245 
 
5713 rajveer 1246 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1247 
    """
1248 
    Parameters:
1249 
     - storeId
1250 
     - fromDate
1251 
     - toDate
1252 
     - onlyCod
1253 
    """
1254 
    pass
1255 
 
5833 rajveer 1256 
  def getOrderAttributeValue(self, orderId, attributeName):
1257 
    """
1258 
    Parameters:
1259 
     - orderId
1260 
     - attributeName
1261 
    """
1262 
    pass
1263 
 
6019 rajveer 1264 
  def changeJacketNumber(self, orderId, jacketNumber):
1265 
    """
1266 
    Parameters:
1267 
     - orderId
1268 
     - jacketNumber
1269 
    """
1270 
    pass
1271 
 
1272 
  def markOrderAsRtoInTransit(self, orderId):
1273 
    """
1274 
    Parameters:
1275 
     - orderId
1276 
    """
1277 
    pass
1278 
 
5593 mandeep.dh 1279 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1280 
    """
1281 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1282 
    invoked while scanning IN of items.
5553 rajveer 1283 
 
5593 mandeep.dh 1284 
    Parameters:
1285 
     - itemId
1286 
     - quantity
1287 
     - fulfilmentWarehouseId
1288 
     - billingWarehouseId
1289 
    """
1290 
    pass
1291 
 
6000 mandeep.dh 1292 
  def createRechargeOrder(self, rechargeOrder):
1293 
    """
1294 
    Parameters:
1295 
     - rechargeOrder
1296 
    """
1297 
    pass
5593 mandeep.dh 1298 
 
6031 rajveer 1299 
  def getRechargeOrder(self, rechargeRrderId):
1300 
    """
1301 
    Parameters:
1302 
     - rechargeRrderId
1303 
    """
1304 
    pass
1305 
 
1306 
  def getRechargeOrders(self, userId):
1307 
    """
1308 
    Parameters:
1309 
     - userId
1310 
    """
1311 
    pass
1312 
 
6000 mandeep.dh 1313 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1314 
    """
1315 
    Parameters:
1316 
     - rechargeOrderId
1317 
     - rechargeOrderStatus
1318 
    """
1319 
    pass
1320 
 
6031 rajveer 1321 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1322 
    """
1323 
    Parameters:
6031 rajveer 1324 
     - rechargeOrderId
6000 mandeep.dh 1325 
    """
1326 
    pass
1327 
 
6031 rajveer 1328 
  def getUserWallet(self, userId):
6000 mandeep.dh 1329 
    """
1330 
    Parameters:
6031 rajveer 1331 
     - userId
6000 mandeep.dh 1332 
    """
1333 
    pass
1334 
 
6031 rajveer 1335 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1336 
    """
1337 
    Parameters:
6031 rajveer 1338 
     - userId
6000 mandeep.dh 1339 
    """
1340 
    pass
1341 
 
6050 anupam.sin 1342 
  def getRechargeOrdersForTransaction(self, txnId):
1343 
    """
1344 
    Returns a recharge order for a given transactionId
1345 
 
1346 
    Parameters:
1347 
     - txnId
1348 
    """
1349 
    pass
1350 
 
6206 rajveer 1351 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1352 
    """
1353 
    Parameters:
1354 
     - rechargeType
6206 rajveer 1355 
     - onlyActive
6048 rajveer 1356 
    """
1357 
    pass
6000 mandeep.dh 1358 
 
6049 rajveer 1359 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1360 
    """
1361 
    Parameters:
6049 rajveer 1362 
     - rechargeType
6048 rajveer 1363 
     - deviceNumber
1364 
    """
1365 
    pass
1366 
 
6591 anupam.sin 1367 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1368 
    """
1369 
    Parameters:
1370 
     - rechargeType
1371 
     - deviceNumber
6307 anupam.sin 1372 
     - userSelectedProviderId
6591 anupam.sin 1373 
     - clientAddress
6269 rajveer 1374 
    """
1375 
    pass
1376 
 
6094 rajveer 1377 
  def getRechargeOrdersForDevice(self, deviceNumber):
1378 
    """
1379 
    Parameters:
1380 
     - deviceNumber
1381 
    """
1382 
    pass
6048 rajveer 1383 
 
6094 rajveer 1384 
  def addAmountToWallet(self, userId, orderId, amount):
1385 
    """
1386 
    Parameters:
1387 
     - userId
1388 
     - orderId
1389 
     - amount
1390 
    """
1391 
    pass
1392 
 
6188 rajveer 1393 
  def getRechargeStatistics(self, ):
1394 
    pass
1395 
 
6154 rajveer 1396 
  def getRechargeOrdersForStatus(self, status):
1397 
    """
1398 
    Parameters:
1399 
     - status
1400 
    """
1401 
    pass
6094 rajveer 1402 
 
6159 rajveer 1403 
  def getPlansForOperator(self, operatorId):
1404 
    """
1405 
    Parameters:
1406 
     - operatorId
1407 
    """
1408 
    pass
6154 rajveer 1409 
 
6307 anupam.sin 1410 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1411 
    """
1412 
    Returns denominations for a given operator and circle
6159 rajveer 1413 
 
6289 anupam.sin 1414 
    Parameters:
1415 
     - operatorId
6307 anupam.sin 1416 
     - circleCode
6289 anupam.sin 1417 
     - denominationType
1418 
    """
1419 
    pass
1420 
 
6371 rajveer 1421 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1422 
    """
1423 
    Parameters:
1424 
     - operatorId
1425 
     - circleId
1426 
     - isAvailable
1427 
    """
1428 
    pass
6289 anupam.sin 1429 
 
6389 rajveer 1430 
  def getAvailableEmiSchemes(self, ):
1431 
    pass
6371 rajveer 1432 
 
6389 rajveer 1433 
  def getMiscCharges(self, transactionId):
1434 
    """
1435 
    Parameters:
1436 
     - transactionId
1437 
    """
1438 
    pass
1439 
 
6507 anupam.sin 1440 
  def refundRechargeOrder(self, rechargeOrderId):
1441 
    """
1442 
    Parameters:
1443 
     - rechargeOrderId
1444 
    """
1445 
    pass
6389 rajveer 1446 
 
6821 amar.kumar 1447 
  def getPhysicalOrders(self, fromDate, toDate):
1448 
    """
1449 
    Parameters:
1450 
     - fromDate
1451 
     - toDate
1452 
    """
1453 
    pass
6507 anupam.sin 1454 
 
6906 rajveer 1455 
  def getDocument(self, docType, docSource):
1456 
    """
1457 
    Parameters:
1458 
     - docType
1459 
     - docSource
1460 
    """
1461 
    pass
6821 amar.kumar 1462 
 
6985 anupam.sin 1463 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1464 
    """
1465 
    Parameters:
1466 
     - orderId
1467 
     - line1
1468 
     - line2
1469 
     - city
1470 
     - state
1471 
     - pin
1472 
    """
1473 
    pass
6906 rajveer 1474 
 
6988 rajveer 1475 
  def retrieveInvoice(self, orderId):
1476 
    """
1477 
    Parameters:
1478 
     - orderId
1479 
    """
1480 
    pass
6985 anupam.sin 1481 
 
7026 rajveer 1482 
  def receiveUpdatesForRedExpress(self, awbNumber):
1483 
    """
1484 
    Parameters:
1485 
     - awbNumber
1486 
    """
1487 
    pass
6988 rajveer 1488 
 
7073 anupam.sin 1489 
  def createRechargeTransaction(self, thriftRechargeTransaction):
1490 
    """
1491 
    Parameters:
1492 
     - thriftRechargeTransaction
1493 
    """
1494 
    pass
7026 rajveer 1495 
 
7073 anupam.sin 1496 
 
3376 rajveer 1497 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1498 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1499 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1500 
 
1501 
  def createTransaction(self, transaction):
1502 
    """
1503 
    Parameters:
1504 
     - transaction
1505 
    """
1506 
    self.send_createTransaction(transaction)
132 ashish 1507 
    return self.recv_createTransaction()
94 ashish 1508 
 
1509 
  def send_createTransaction(self, transaction):
1510 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1511 
    args = createTransaction_args()
1512 
    args.transaction = transaction
1513 
    args.write(self._oprot)
1514 
    self._oprot.writeMessageEnd()
1515 
    self._oprot.trans.flush()
1516 
 
1517 
  def recv_createTransaction(self, ):
1518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1519 
    if mtype == TMessageType.EXCEPTION:
1520 
      x = TApplicationException()
1521 
      x.read(self._iprot)
1522 
      self._iprot.readMessageEnd()
1523 
      raise x
1524 
    result = createTransaction_result()
1525 
    result.read(self._iprot)
1526 
    self._iprot.readMessageEnd()
3431 rajveer 1527 
    if result.success is not None:
132 ashish 1528 
      return result.success
3431 rajveer 1529 
    if result.ex is not None:
94 ashish 1530 
      raise result.ex
132 ashish 1531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1532 
 
1533 
  def getTransaction(self, id):
1534 
    """
1535 
    Parameters:
1536 
     - id
1537 
    """
1538 
    self.send_getTransaction(id)
1539 
    return self.recv_getTransaction()
1540 
 
1541 
  def send_getTransaction(self, id):
1542 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1543 
    args = getTransaction_args()
1544 
    args.id = id
1545 
    args.write(self._oprot)
1546 
    self._oprot.writeMessageEnd()
1547 
    self._oprot.trans.flush()
1548 
 
1549 
  def recv_getTransaction(self, ):
1550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1551 
    if mtype == TMessageType.EXCEPTION:
1552 
      x = TApplicationException()
1553 
      x.read(self._iprot)
1554 
      self._iprot.readMessageEnd()
1555 
      raise x
1556 
    result = getTransaction_result()
1557 
    result.read(self._iprot)
1558 
    self._iprot.readMessageEnd()
3431 rajveer 1559 
    if result.success is not None:
94 ashish 1560 
      return result.success
3431 rajveer 1561 
    if result.ex is not None:
94 ashish 1562 
      raise result.ex
1563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1564 
 
1565 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1566 
    """
1567 
    Parameters:
1568 
     - customerId
1569 
     - from_date
1570 
     - to_date
1571 
     - status
1572 
    """
1573 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1574 
    return self.recv_getTransactionsForCustomer()
1575 
 
1576 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1577 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1578 
    args = getTransactionsForCustomer_args()
1579 
    args.customerId = customerId
1580 
    args.from_date = from_date
1581 
    args.to_date = to_date
1582 
    args.status = status
1583 
    args.write(self._oprot)
1584 
    self._oprot.writeMessageEnd()
1585 
    self._oprot.trans.flush()
1586 
 
1587 
  def recv_getTransactionsForCustomer(self, ):
1588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1589 
    if mtype == TMessageType.EXCEPTION:
1590 
      x = TApplicationException()
1591 
      x.read(self._iprot)
1592 
      self._iprot.readMessageEnd()
1593 
      raise x
1594 
    result = getTransactionsForCustomer_result()
1595 
    result.read(self._iprot)
1596 
    self._iprot.readMessageEnd()
3431 rajveer 1597 
    if result.success is not None:
94 ashish 1598 
      return result.success
3431 rajveer 1599 
    if result.ex is not None:
94 ashish 1600 
      raise result.ex
1601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1602 
 
132 ashish 1603 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1604 
    """
1605 
    Parameters:
1606 
     - shoppingCartId
1607 
    """
1608 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1609 
    return self.recv_getTransactionsForShoppingCartId()
1610 
 
1611 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1612 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1613 
    args = getTransactionsForShoppingCartId_args()
1614 
    args.shoppingCartId = shoppingCartId
1615 
    args.write(self._oprot)
1616 
    self._oprot.writeMessageEnd()
1617 
    self._oprot.trans.flush()
1618 
 
1619 
  def recv_getTransactionsForShoppingCartId(self, ):
1620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1621 
    if mtype == TMessageType.EXCEPTION:
1622 
      x = TApplicationException()
1623 
      x.read(self._iprot)
1624 
      self._iprot.readMessageEnd()
1625 
      raise x
1626 
    result = getTransactionsForShoppingCartId_result()
1627 
    result.read(self._iprot)
1628 
    self._iprot.readMessageEnd()
3431 rajveer 1629 
    if result.success is not None:
132 ashish 1630 
      return result.success
3431 rajveer 1631 
    if result.ex is not None:
132 ashish 1632 
      raise result.ex
1633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1634 
 
94 ashish 1635 
  def getTransactionStatus(self, transactionId):
1636 
    """
1637 
    Parameters:
1638 
     - transactionId
1639 
    """
1640 
    self.send_getTransactionStatus(transactionId)
1641 
    return self.recv_getTransactionStatus()
1642 
 
1643 
  def send_getTransactionStatus(self, transactionId):
1644 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1645 
    args = getTransactionStatus_args()
1646 
    args.transactionId = transactionId
1647 
    args.write(self._oprot)
1648 
    self._oprot.writeMessageEnd()
1649 
    self._oprot.trans.flush()
1650 
 
1651 
  def recv_getTransactionStatus(self, ):
1652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1653 
    if mtype == TMessageType.EXCEPTION:
1654 
      x = TApplicationException()
1655 
      x.read(self._iprot)
1656 
      self._iprot.readMessageEnd()
1657 
      raise x
1658 
    result = getTransactionStatus_result()
1659 
    result.read(self._iprot)
1660 
    self._iprot.readMessageEnd()
3431 rajveer 1661 
    if result.success is not None:
94 ashish 1662 
      return result.success
3431 rajveer 1663 
    if result.ex is not None:
94 ashish 1664 
      raise result.ex
1665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1666 
 
5527 anupam.sin 1667 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1668 
    """
1669 
    Parameters:
1670 
     - transactionId
1671 
     - status
1672 
     - description
5527 anupam.sin 1673 
     - pickUp
1674 
     - orderType
94 ashish 1675 
    """
5527 anupam.sin 1676 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1677 
    return self.recv_changeTransactionStatus()
1678 
 
5527 anupam.sin 1679 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1680 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1681 
    args = changeTransactionStatus_args()
1682 
    args.transactionId = transactionId
1683 
    args.status = status
1684 
    args.description = description
5527 anupam.sin 1685 
    args.pickUp = pickUp
1686 
    args.orderType = orderType
94 ashish 1687 
    args.write(self._oprot)
1688 
    self._oprot.writeMessageEnd()
1689 
    self._oprot.trans.flush()
1690 
 
1691 
  def recv_changeTransactionStatus(self, ):
1692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1693 
    if mtype == TMessageType.EXCEPTION:
1694 
      x = TApplicationException()
1695 
      x.read(self._iprot)
1696 
      self._iprot.readMessageEnd()
1697 
      raise x
1698 
    result = changeTransactionStatus_result()
1699 
    result.read(self._iprot)
1700 
    self._iprot.readMessageEnd()
3431 rajveer 1701 
    if result.success is not None:
94 ashish 1702 
      return result.success
3431 rajveer 1703 
    if result.ex is not None:
94 ashish 1704 
      raise result.ex
1705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1706 
 
1398 varun.gupt 1707 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1708 
    """
1709 
    Parameters:
1710 
     - transactionId
1711 
    """
1398 varun.gupt 1712 
    self.send_enqueueTransactionInfoEmail(transactionId)
1713 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1714 
 
1398 varun.gupt 1715 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1716 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1717 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1718 
    args.transactionId = transactionId
1719 
    args.write(self._oprot)
1720 
    self._oprot.writeMessageEnd()
1721 
    self._oprot.trans.flush()
1722 
 
1398 varun.gupt 1723 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1725 
    if mtype == TMessageType.EXCEPTION:
1726 
      x = TApplicationException()
1727 
      x.read(self._iprot)
1728 
      self._iprot.readMessageEnd()
1729 
      raise x
1398 varun.gupt 1730 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1731 
    result.read(self._iprot)
1732 
    self._iprot.readMessageEnd()
3431 rajveer 1733 
    if result.success is not None:
1382 varun.gupt 1734 
      return result.success
3431 rajveer 1735 
    if result.ex is not None:
1382 varun.gupt 1736 
      raise result.ex
1398 varun.gupt 1737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1738 
 
4801 anupam.sin 1739 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1740 
    """
1741 
    Parameters:
4801 anupam.sin 1742 
     - statuses
483 rajveer 1743 
     - from_date
1744 
     - to_date
1745 
     - warehouse_id
94 ashish 1746 
    """
4801 anupam.sin 1747 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1748 
    return self.recv_getAllOrders()
94 ashish 1749 
 
4801 anupam.sin 1750 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1751 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1752 
    args = getAllOrders_args()
4801 anupam.sin 1753 
    args.statuses = statuses
483 rajveer 1754 
    args.from_date = from_date
1755 
    args.to_date = to_date
1756 
    args.warehouse_id = warehouse_id
94 ashish 1757 
    args.write(self._oprot)
1758 
    self._oprot.writeMessageEnd()
1759 
    self._oprot.trans.flush()
1760 
 
483 rajveer 1761 
  def recv_getAllOrders(self, ):
94 ashish 1762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1763 
    if mtype == TMessageType.EXCEPTION:
1764 
      x = TApplicationException()
1765 
      x.read(self._iprot)
1766 
      self._iprot.readMessageEnd()
1767 
      raise x
483 rajveer 1768 
    result = getAllOrders_result()
94 ashish 1769 
    result.read(self._iprot)
1770 
    self._iprot.readMessageEnd()
3431 rajveer 1771 
    if result.success is not None:
94 ashish 1772 
      return result.success
3431 rajveer 1773 
    if result.ex is not None:
94 ashish 1774 
      raise result.ex
483 rajveer 1775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1776 
 
4133 chandransh 1777 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1778 
    """
1779 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1780 
    Pass the status as null and the limit as 0 to ignore them.
1781 
 
1782 
    Parameters:
1783 
     - statuses
1784 
     - offset
1785 
     - limit
1786 
     - warehouse_id
1787 
    """
1788 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1789 
    return self.recv_getOrdersInBatch()
1790 
 
1791 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1792 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1793 
    args = getOrdersInBatch_args()
1794 
    args.statuses = statuses
1795 
    args.offset = offset
1796 
    args.limit = limit
1797 
    args.warehouse_id = warehouse_id
1798 
    args.write(self._oprot)
1799 
    self._oprot.writeMessageEnd()
1800 
    self._oprot.trans.flush()
1801 
 
1802 
  def recv_getOrdersInBatch(self, ):
1803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1804 
    if mtype == TMessageType.EXCEPTION:
1805 
      x = TApplicationException()
1806 
      x.read(self._iprot)
1807 
      self._iprot.readMessageEnd()
1808 
      raise x
1809 
    result = getOrdersInBatch_result()
1810 
    result.read(self._iprot)
1811 
    self._iprot.readMessageEnd()
1812 
    if result.success is not None:
1813 
      return result.success
1814 
    if result.ex is not None:
1815 
      raise result.ex
1816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1817 
 
1818 
  def getOrderCount(self, statuses, warehouseId):
1819 
    """
1820 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1821 
 
1822 
    Parameters:
1823 
     - statuses
1824 
     - warehouseId
1825 
    """
1826 
    self.send_getOrderCount(statuses, warehouseId)
1827 
    return self.recv_getOrderCount()
1828 
 
1829 
  def send_getOrderCount(self, statuses, warehouseId):
1830 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1831 
    args = getOrderCount_args()
1832 
    args.statuses = statuses
1833 
    args.warehouseId = warehouseId
1834 
    args.write(self._oprot)
1835 
    self._oprot.writeMessageEnd()
1836 
    self._oprot.trans.flush()
1837 
 
1838 
  def recv_getOrderCount(self, ):
1839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1840 
    if mtype == TMessageType.EXCEPTION:
1841 
      x = TApplicationException()
1842 
      x.read(self._iprot)
1843 
      self._iprot.readMessageEnd()
1844 
      raise x
1845 
    result = getOrderCount_result()
1846 
    result.read(self._iprot)
1847 
    self._iprot.readMessageEnd()
1848 
    if result.success is not None:
1849 
      return result.success
1850 
    if result.ex is not None:
1851 
      raise result.ex
1852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1853 
 
999 varun.gupt 1854 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1855 
    """
1132 chandransh 1856 
    Returns orders within a range of their billing dates
3431 rajveer 1857 
 
999 varun.gupt 1858 
    Parameters:
1859 
     - status
1860 
     - start_billing_date
1861 
     - end_billing_date
1862 
     - warehouse_id
1863 
    """
1864 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1865 
    return self.recv_getOrdersByBillingDate()
1866 
 
1867 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1868 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1869 
    args = getOrdersByBillingDate_args()
1870 
    args.status = status
1871 
    args.start_billing_date = start_billing_date
1872 
    args.end_billing_date = end_billing_date
1873 
    args.warehouse_id = warehouse_id
1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
1878 
  def recv_getOrdersByBillingDate(self, ):
1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
1885 
    result = getOrdersByBillingDate_result()
1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
999 varun.gupt 1889 
      return result.success
3431 rajveer 1890 
    if result.ex is not None:
999 varun.gupt 1891 
      raise result.ex
1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1893 
 
3451 chandransh 1894 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1895 
    """
1896 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1897 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1898 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1899 
 
3427 chandransh 1900 
    Parameters:
1901 
     - fromShippingDate
1902 
     - toShippingDate
1903 
     - providerId
1904 
     - warehouseId
3451 chandransh 1905 
     - cod
3427 chandransh 1906 
    """
3451 chandransh 1907 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1908 
    return self.recv_getOrdersByShippingDate()
1909 
 
3451 chandransh 1910 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1911 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1912 
    args = getOrdersByShippingDate_args()
1913 
    args.fromShippingDate = fromShippingDate
1914 
    args.toShippingDate = toShippingDate
1915 
    args.providerId = providerId
1916 
    args.warehouseId = warehouseId
3451 chandransh 1917 
    args.cod = cod
3427 chandransh 1918 
    args.write(self._oprot)
1919 
    self._oprot.writeMessageEnd()
1920 
    self._oprot.trans.flush()
1921 
 
1922 
  def recv_getOrdersByShippingDate(self, ):
1923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1924 
    if mtype == TMessageType.EXCEPTION:
1925 
      x = TApplicationException()
1926 
      x.read(self._iprot)
1927 
      self._iprot.readMessageEnd()
1928 
      raise x
1929 
    result = getOrdersByShippingDate_result()
1930 
    result.read(self._iprot)
1931 
    self._iprot.readMessageEnd()
3431 rajveer 1932 
    if result.success is not None:
3427 chandransh 1933 
      return result.success
3431 rajveer 1934 
    if result.ex is not None:
3427 chandransh 1935 
      raise result.ex
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1937 
 
1382 varun.gupt 1938 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1939 
    """
1940 
    Returns order ids for orders which can be returned
3431 rajveer 1941 
 
1382 varun.gupt 1942 
    Parameters:
1943 
     - customer_id
1944 
     - limit
1945 
    """
1946 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1947 
    return self.recv_getReturnableOrdersForCustomer()
1948 
 
1949 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1950 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1951 
    args = getReturnableOrdersForCustomer_args()
1952 
    args.customer_id = customer_id
1953 
    args.limit = limit
1954 
    args.write(self._oprot)
1955 
    self._oprot.writeMessageEnd()
1956 
    self._oprot.trans.flush()
1957 
 
1958 
  def recv_getReturnableOrdersForCustomer(self, ):
1959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1960 
    if mtype == TMessageType.EXCEPTION:
1961 
      x = TApplicationException()
1962 
      x.read(self._iprot)
1963 
      self._iprot.readMessageEnd()
1964 
      raise x
1965 
    result = getReturnableOrdersForCustomer_result()
1966 
    result.read(self._iprot)
1967 
    self._iprot.readMessageEnd()
3431 rajveer 1968 
    if result.success is not None:
1382 varun.gupt 1969 
      return result.success
3431 rajveer 1970 
    if result.ex is not None:
1382 varun.gupt 1971 
      raise result.ex
1972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1973 
 
1974 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1975 
    """
1976 
    Returns order ids for orders which can be cancelled
3431 rajveer 1977 
 
1382 varun.gupt 1978 
    Parameters:
1979 
     - customer_id
1980 
     - limit
1981 
    """
1982 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1983 
    return self.recv_getCancellableOrdersForCustomer()
1984 
 
1985 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1986 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1987 
    args = getCancellableOrdersForCustomer_args()
1988 
    args.customer_id = customer_id
1989 
    args.limit = limit
1990 
    args.write(self._oprot)
1991 
    self._oprot.writeMessageEnd()
1992 
    self._oprot.trans.flush()
1993 
 
1994 
  def recv_getCancellableOrdersForCustomer(self, ):
1995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1996 
    if mtype == TMessageType.EXCEPTION:
1997 
      x = TApplicationException()
1998 
      x.read(self._iprot)
1999 
      self._iprot.readMessageEnd()
2000 
      raise x
2001 
    result = getCancellableOrdersForCustomer_result()
2002 
    result.read(self._iprot)
2003 
    self._iprot.readMessageEnd()
3431 rajveer 2004 
    if result.success is not None:
1382 varun.gupt 2005 
      return result.success
3431 rajveer 2006 
    if result.ex is not None:
1382 varun.gupt 2007 
      raise result.ex
2008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2009 
 
483 rajveer 2010 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2011 
    """
2012 
    Parameters:
483 rajveer 2013 
     - orderId
2014 
     - status
2015 
     - description
94 ashish 2016 
    """
483 rajveer 2017 
    self.send_changeOrderStatus(orderId, status, description)
2018 
    return self.recv_changeOrderStatus()
94 ashish 2019 
 
483 rajveer 2020 
  def send_changeOrderStatus(self, orderId, status, description):
2021 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2022 
    args = changeOrderStatus_args()
2023 
    args.orderId = orderId
2024 
    args.status = status
2025 
    args.description = description
94 ashish 2026 
    args.write(self._oprot)
2027 
    self._oprot.writeMessageEnd()
2028 
    self._oprot.trans.flush()
2029 
 
483 rajveer 2030 
  def recv_changeOrderStatus(self, ):
94 ashish 2031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2032 
    if mtype == TMessageType.EXCEPTION:
2033 
      x = TApplicationException()
2034 
      x.read(self._iprot)
2035 
      self._iprot.readMessageEnd()
2036 
      raise x
483 rajveer 2037 
    result = changeOrderStatus_result()
94 ashish 2038 
    result.read(self._iprot)
2039 
    self._iprot.readMessageEnd()
3431 rajveer 2040 
    if result.success is not None:
94 ashish 2041 
      return result.success
3431 rajveer 2042 
    if result.ex is not None:
94 ashish 2043 
      raise result.ex
483 rajveer 2044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2045 
 
1528 ankur.sing 2046 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2047 
    """
1528 ankur.sing 2048 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2049 
    only user who owns the transaction can view its order details.
3431 rajveer 2050 
 
94 ashish 2051 
    Parameters:
2052 
     - transactionId
1528 ankur.sing 2053 
     - customerId
94 ashish 2054 
    """
1528 ankur.sing 2055 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2056 
    return self.recv_getOrdersForTransaction()
94 ashish 2057 
 
1528 ankur.sing 2058 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2059 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2060 
    args = getOrdersForTransaction_args()
94 ashish 2061 
    args.transactionId = transactionId
1528 ankur.sing 2062 
    args.customerId = customerId
94 ashish 2063 
    args.write(self._oprot)
2064 
    self._oprot.writeMessageEnd()
2065 
    self._oprot.trans.flush()
2066 
 
483 rajveer 2067 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2069 
    if mtype == TMessageType.EXCEPTION:
2070 
      x = TApplicationException()
2071 
      x.read(self._iprot)
2072 
      self._iprot.readMessageEnd()
2073 
      raise x
483 rajveer 2074 
    result = getOrdersForTransaction_result()
94 ashish 2075 
    result.read(self._iprot)
2076 
    self._iprot.readMessageEnd()
3431 rajveer 2077 
    if result.success is not None:
94 ashish 2078 
      return result.success
3431 rajveer 2079 
    if result.ex is not None:
94 ashish 2080 
      raise result.ex
483 rajveer 2081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2082 
 
3014 chandransh 2083 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2084 
    """
3014 chandransh 2085 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2086 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2087 
 
94 ashish 2088 
    Parameters:
483 rajveer 2089 
     - customerId
2090 
     - from_date
2091 
     - to_date
3014 chandransh 2092 
     - statuses
94 ashish 2093 
    """
3014 chandransh 2094 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2095 
    return self.recv_getOrdersForCustomer()
94 ashish 2096 
 
3014 chandransh 2097 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2098 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2099 
    args = getOrdersForCustomer_args()
2100 
    args.customerId = customerId
2101 
    args.from_date = from_date
2102 
    args.to_date = to_date
3014 chandransh 2103 
    args.statuses = statuses
94 ashish 2104 
    args.write(self._oprot)
2105 
    self._oprot.writeMessageEnd()
2106 
    self._oprot.trans.flush()
2107 
 
483 rajveer 2108 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2110 
    if mtype == TMessageType.EXCEPTION:
2111 
      x = TApplicationException()
2112 
      x.read(self._iprot)
2113 
      self._iprot.readMessageEnd()
2114 
      raise x
483 rajveer 2115 
    result = getOrdersForCustomer_result()
94 ashish 2116 
    result.read(self._iprot)
2117 
    self._iprot.readMessageEnd()
3431 rajveer 2118 
    if result.success is not None:
94 ashish 2119 
      return result.success
3431 rajveer 2120 
    if result.ex is not None:
94 ashish 2121 
      raise result.ex
483 rajveer 2122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2123 
 
483 rajveer 2124 
  def createOrder(self, order):
94 ashish 2125 
    """
2126 
    Parameters:
483 rajveer 2127 
     - order
94 ashish 2128 
    """
483 rajveer 2129 
    self.send_createOrder(order)
2130 
    return self.recv_createOrder()
94 ashish 2131 
 
483 rajveer 2132 
  def send_createOrder(self, order):
2133 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2134 
    args = createOrder_args()
2135 
    args.order = order
94 ashish 2136 
    args.write(self._oprot)
2137 
    self._oprot.writeMessageEnd()
2138 
    self._oprot.trans.flush()
2139 
 
483 rajveer 2140 
  def recv_createOrder(self, ):
94 ashish 2141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2142 
    if mtype == TMessageType.EXCEPTION:
2143 
      x = TApplicationException()
2144 
      x.read(self._iprot)
2145 
      self._iprot.readMessageEnd()
2146 
      raise x
483 rajveer 2147 
    result = createOrder_result()
94 ashish 2148 
    result.read(self._iprot)
2149 
    self._iprot.readMessageEnd()
3431 rajveer 2150 
    if result.success is not None:
94 ashish 2151 
      return result.success
3431 rajveer 2152 
    if result.ex is not None:
94 ashish 2153 
      raise result.ex
483 rajveer 2154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2155 
 
483 rajveer 2156 
  def getOrder(self, id):
94 ashish 2157 
    """
2158 
    Parameters:
483 rajveer 2159 
     - id
94 ashish 2160 
    """
483 rajveer 2161 
    self.send_getOrder(id)
2162 
    return self.recv_getOrder()
94 ashish 2163 
 
483 rajveer 2164 
  def send_getOrder(self, id):
2165 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2166 
    args = getOrder_args()
2167 
    args.id = id
94 ashish 2168 
    args.write(self._oprot)
2169 
    self._oprot.writeMessageEnd()
2170 
    self._oprot.trans.flush()
2171 
 
483 rajveer 2172 
  def recv_getOrder(self, ):
94 ashish 2173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2174 
    if mtype == TMessageType.EXCEPTION:
2175 
      x = TApplicationException()
2176 
      x.read(self._iprot)
2177 
      self._iprot.readMessageEnd()
2178 
      raise x
483 rajveer 2179 
    result = getOrder_result()
94 ashish 2180 
    result.read(self._iprot)
2181 
    self._iprot.readMessageEnd()
3431 rajveer 2182 
    if result.success is not None:
94 ashish 2183 
      return result.success
3431 rajveer 2184 
    if result.ex is not None:
94 ashish 2185 
      raise result.ex
483 rajveer 2186 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2187 
 
483 rajveer 2188 
  def getLineItemsForOrder(self, orderId):
94 ashish 2189 
    """
2190 
    Parameters:
483 rajveer 2191 
     - orderId
94 ashish 2192 
    """
483 rajveer 2193 
    self.send_getLineItemsForOrder(orderId)
2194 
    return self.recv_getLineItemsForOrder()
94 ashish 2195 
 
483 rajveer 2196 
  def send_getLineItemsForOrder(self, orderId):
2197 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2198 
    args = getLineItemsForOrder_args()
2199 
    args.orderId = orderId
94 ashish 2200 
    args.write(self._oprot)
2201 
    self._oprot.writeMessageEnd()
2202 
    self._oprot.trans.flush()
2203 
 
483 rajveer 2204 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2206 
    if mtype == TMessageType.EXCEPTION:
2207 
      x = TApplicationException()
2208 
      x.read(self._iprot)
2209 
      self._iprot.readMessageEnd()
2210 
      raise x
483 rajveer 2211 
    result = getLineItemsForOrder_result()
94 ashish 2212 
    result.read(self._iprot)
2213 
    self._iprot.readMessageEnd()
3431 rajveer 2214 
    if result.success is not None:
94 ashish 2215 
      return result.success
3431 rajveer 2216 
    if result.ex is not None:
94 ashish 2217 
      raise result.ex
483 rajveer 2218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2219 
 
4999 phani.kuma 2220 
  def getOrderList(self, order_ids):
2221 
    """
2222 
    Parameters:
2223 
     - order_ids
2224 
    """
2225 
    self.send_getOrderList(order_ids)
2226 
    return self.recv_getOrderList()
2227 
 
2228 
  def send_getOrderList(self, order_ids):
2229 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2230 
    args = getOrderList_args()
2231 
    args.order_ids = order_ids
2232 
    args.write(self._oprot)
2233 
    self._oprot.writeMessageEnd()
2234 
    self._oprot.trans.flush()
2235 
 
2236 
  def recv_getOrderList(self, ):
2237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2238 
    if mtype == TMessageType.EXCEPTION:
2239 
      x = TApplicationException()
2240 
      x.read(self._iprot)
2241 
      self._iprot.readMessageEnd()
2242 
      raise x
2243 
    result = getOrderList_result()
2244 
    result.read(self._iprot)
2245 
    self._iprot.readMessageEnd()
2246 
    if result.success is not None:
2247 
      return result.success
2248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2249 
 
5386 phani.kuma 2250 
  def getOrderListForVendor(self, order_ids, vendorId):
2251 
    """
2252 
    Parameters:
2253 
     - order_ids
2254 
     - vendorId
2255 
    """
2256 
    self.send_getOrderListForVendor(order_ids, vendorId)
2257 
    return self.recv_getOrderListForVendor()
2258 
 
2259 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2260 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2261 
    args = getOrderListForVendor_args()
2262 
    args.order_ids = order_ids
2263 
    args.vendorId = vendorId
2264 
    args.write(self._oprot)
2265 
    self._oprot.writeMessageEnd()
2266 
    self._oprot.trans.flush()
2267 
 
2268 
  def recv_getOrderListForVendor(self, ):
2269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2270 
    if mtype == TMessageType.EXCEPTION:
2271 
      x = TApplicationException()
2272 
      x.read(self._iprot)
2273 
      self._iprot.readMessageEnd()
2274 
      raise x
2275 
    result = getOrderListForVendor_result()
2276 
    result.read(self._iprot)
2277 
    self._iprot.readMessageEnd()
2278 
    if result.success is not None:
2279 
      return result.success
2280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2281 
 
1528 ankur.sing 2282 
  def getOrderForCustomer(self, orderId, customerId):
2283 
    """
2284 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2285 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2286 
 
1528 ankur.sing 2287 
    Parameters:
2288 
     - orderId
2289 
     - customerId
2290 
    """
2291 
    self.send_getOrderForCustomer(orderId, customerId)
2292 
    return self.recv_getOrderForCustomer()
2293 
 
2294 
  def send_getOrderForCustomer(self, orderId, customerId):
2295 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2296 
    args = getOrderForCustomer_args()
2297 
    args.orderId = orderId
2298 
    args.customerId = customerId
2299 
    args.write(self._oprot)
2300 
    self._oprot.writeMessageEnd()
2301 
    self._oprot.trans.flush()
2302 
 
2303 
  def recv_getOrderForCustomer(self, ):
2304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2305 
    if mtype == TMessageType.EXCEPTION:
2306 
      x = TApplicationException()
2307 
      x.read(self._iprot)
2308 
      self._iprot.readMessageEnd()
2309 
      raise x
2310 
    result = getOrderForCustomer_result()
2311 
    result.read(self._iprot)
2312 
    self._iprot.readMessageEnd()
3431 rajveer 2313 
    if result.success is not None:
1528 ankur.sing 2314 
      return result.success
3431 rajveer 2315 
    if result.ex is not None:
1528 ankur.sing 2316 
      raise result.ex
2317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2318 
 
4444 rajveer 2319 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2320 
    """
2321 
    Parameters:
4394 rajveer 2322 
     - type
4444 rajveer 2323 
     - warehouseId
4394 rajveer 2324 
     - status
2325 
     - timestamp
3064 chandransh 2326 
    """
4444 rajveer 2327 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2328 
    return self.recv_getAlerts()
2329 
 
4444 rajveer 2330 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2331 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2332 
    args = getAlerts_args()
4394 rajveer 2333 
    args.type = type
4444 rajveer 2334 
    args.warehouseId = warehouseId
4394 rajveer 2335 
    args.status = status
2336 
    args.timestamp = timestamp
3064 chandransh 2337 
    args.write(self._oprot)
2338 
    self._oprot.writeMessageEnd()
2339 
    self._oprot.trans.flush()
2340 
 
2341 
  def recv_getAlerts(self, ):
2342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2343 
    if mtype == TMessageType.EXCEPTION:
2344 
      x = TApplicationException()
2345 
      x.read(self._iprot)
2346 
      self._iprot.readMessageEnd()
2347 
      raise x
2348 
    result = getAlerts_result()
2349 
    result.read(self._iprot)
2350 
    self._iprot.readMessageEnd()
3431 rajveer 2351 
    if result.success is not None:
3064 chandransh 2352 
      return result.success
2353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2354 
 
4444 rajveer 2355 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2356 
    """
2357 
    Parameters:
2358 
     - type
4444 rajveer 2359 
     - warehouseId
4394 rajveer 2360 
     - description
3064 chandransh 2361 
    """
4444 rajveer 2362 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2363 
    self.recv_addAlert()
3064 chandransh 2364 
 
4444 rajveer 2365 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2366 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2367 
    args = addAlert_args()
3064 chandransh 2368 
    args.type = type
4444 rajveer 2369 
    args.warehouseId = warehouseId
4394 rajveer 2370 
    args.description = description
3064 chandransh 2371 
    args.write(self._oprot)
2372 
    self._oprot.writeMessageEnd()
2373 
    self._oprot.trans.flush()
2374 
 
4394 rajveer 2375 
  def recv_addAlert(self, ):
3064 chandransh 2376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2377 
    if mtype == TMessageType.EXCEPTION:
2378 
      x = TApplicationException()
2379 
      x.read(self._iprot)
2380 
      self._iprot.readMessageEnd()
2381 
      raise x
4394 rajveer 2382 
    result = addAlert_result()
3064 chandransh 2383 
    result.read(self._iprot)
2384 
    self._iprot.readMessageEnd()
2385 
    return
2386 
 
4444 rajveer 2387 
  def markAlertsAsSeen(self, warehouseId):
2388 
    """
2389 
    Parameters:
2390 
     - warehouseId
2391 
    """
2392 
    self.send_markAlertsAsSeen(warehouseId)
2393 
    self.recv_markAlertsAsSeen()
2394 
 
2395 
  def send_markAlertsAsSeen(self, warehouseId):
2396 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2397 
    args = markAlertsAsSeen_args()
2398 
    args.warehouseId = warehouseId
2399 
    args.write(self._oprot)
2400 
    self._oprot.writeMessageEnd()
2401 
    self._oprot.trans.flush()
2402 
 
2403 
  def recv_markAlertsAsSeen(self, ):
2404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2405 
    if mtype == TMessageType.EXCEPTION:
2406 
      x = TApplicationException()
2407 
      x.read(self._iprot)
2408 
      self._iprot.readMessageEnd()
2409 
      raise x
2410 
    result = markAlertsAsSeen_result()
2411 
    result.read(self._iprot)
2412 
    self._iprot.readMessageEnd()
2413 
    return
2414 
 
3064 chandransh 2415 
  def getValidOrderCount(self, ):
2416 
    """
2417 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2418 
    """
2419 
    self.send_getValidOrderCount()
2420 
    return self.recv_getValidOrderCount()
2421 
 
2422 
  def send_getValidOrderCount(self, ):
2423 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2424 
    args = getValidOrderCount_args()
2425 
    args.write(self._oprot)
2426 
    self._oprot.writeMessageEnd()
2427 
    self._oprot.trans.flush()
2428 
 
2429 
  def recv_getValidOrderCount(self, ):
2430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2431 
    if mtype == TMessageType.EXCEPTION:
2432 
      x = TApplicationException()
2433 
      x.read(self._iprot)
2434 
      self._iprot.readMessageEnd()
2435 
      raise x
2436 
    result = getValidOrderCount_result()
2437 
    result.read(self._iprot)
2438 
    self._iprot.readMessageEnd()
3431 rajveer 2439 
    if result.success is not None:
3064 chandransh 2440 
      return result.success
2441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2442 
 
2443 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2444 
    """
2445 
    Returns the number of distinct customers who have done successful transactions
2446 
    """
2447 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2448 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2449 
 
2450 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2451 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2452 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2453 
    args.write(self._oprot)
2454 
    self._oprot.writeMessageEnd()
2455 
    self._oprot.trans.flush()
2456 
 
2457 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2459 
    if mtype == TMessageType.EXCEPTION:
2460 
      x = TApplicationException()
2461 
      x.read(self._iprot)
2462 
      self._iprot.readMessageEnd()
2463 
      raise x
2464 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2465 
    result.read(self._iprot)
2466 
    self._iprot.readMessageEnd()
3431 rajveer 2467 
    if result.success is not None:
3064 chandransh 2468 
      return result.success
2469 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2470 
 
2471 
  def getValidOrdersAmountRange(self, ):
2472 
    """
2473 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2474 
    List contains two values, first minimum amount and second maximum amount.
2475 
    """
2476 
    self.send_getValidOrdersAmountRange()
2477 
    return self.recv_getValidOrdersAmountRange()
2478 
 
2479 
  def send_getValidOrdersAmountRange(self, ):
2480 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2481 
    args = getValidOrdersAmountRange_args()
2482 
    args.write(self._oprot)
2483 
    self._oprot.writeMessageEnd()
2484 
    self._oprot.trans.flush()
2485 
 
2486 
  def recv_getValidOrdersAmountRange(self, ):
2487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2488 
    if mtype == TMessageType.EXCEPTION:
2489 
      x = TApplicationException()
2490 
      x.read(self._iprot)
2491 
      self._iprot.readMessageEnd()
2492 
      raise x
2493 
    result = getValidOrdersAmountRange_result()
2494 
    result.read(self._iprot)
2495 
    self._iprot.readMessageEnd()
3431 rajveer 2496 
    if result.success is not None:
3064 chandransh 2497 
      return result.success
2498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2499 
 
5874 rajveer 2500 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2501 
    """
2502 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2503 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2504 
 
3064 chandransh 2505 
    Parameters:
2506 
     - limit
5874 rajveer 2507 
     - onlyStore
3064 chandransh 2508 
    """
5874 rajveer 2509 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2510 
    return self.recv_getValidOrders()
2511 
 
5874 rajveer 2512 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2513 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2514 
    args = getValidOrders_args()
2515 
    args.limit = limit
5874 rajveer 2516 
    args.onlyStore = onlyStore
3064 chandransh 2517 
    args.write(self._oprot)
2518 
    self._oprot.writeMessageEnd()
2519 
    self._oprot.trans.flush()
2520 
 
2521 
  def recv_getValidOrders(self, ):
2522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2523 
    if mtype == TMessageType.EXCEPTION:
2524 
      x = TApplicationException()
2525 
      x.read(self._iprot)
2526 
      self._iprot.readMessageEnd()
2527 
      raise x
2528 
    result = getValidOrders_result()
2529 
    result.read(self._iprot)
2530 
    self._iprot.readMessageEnd()
3431 rajveer 2531 
    if result.success is not None:
3064 chandransh 2532 
      return result.success
2533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2534 
 
1220 chandransh 2535 
  def batchOrders(self, warehouseId):
2536 
    """
2537 
    Create a batch of all the pending orders for the given warehouse.
2538 
    The returned list is orderd by created_timestamp.
2539 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2540 
 
1220 chandransh 2541 
    Parameters:
2542 
     - warehouseId
2543 
    """
2544 
    self.send_batchOrders(warehouseId)
2545 
    return self.recv_batchOrders()
2546 
 
2547 
  def send_batchOrders(self, warehouseId):
2548 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2549 
    args = batchOrders_args()
2550 
    args.warehouseId = warehouseId
2551 
    args.write(self._oprot)
2552 
    self._oprot.writeMessageEnd()
2553 
    self._oprot.trans.flush()
2554 
 
2555 
  def recv_batchOrders(self, ):
2556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2557 
    if mtype == TMessageType.EXCEPTION:
2558 
      x = TApplicationException()
2559 
      x.read(self._iprot)
2560 
      self._iprot.readMessageEnd()
2561 
      raise x
2562 
    result = batchOrders_result()
2563 
    result.read(self._iprot)
2564 
    self._iprot.readMessageEnd()
3431 rajveer 2565 
    if result.success is not None:
1220 chandransh 2566 
      return result.success
3431 rajveer 2567 
    if result.ex is not None:
1220 chandransh 2568 
      raise result.ex
2569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2570 
 
1208 chandransh 2571 
  def markOrderAsOutOfStock(self, orderId):
2572 
    """
2573 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2574 
 
1208 chandransh 2575 
    Parameters:
2576 
     - orderId
2577 
    """
2578 
    self.send_markOrderAsOutOfStock(orderId)
2579 
    return self.recv_markOrderAsOutOfStock()
2580 
 
2581 
  def send_markOrderAsOutOfStock(self, orderId):
2582 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2583 
    args = markOrderAsOutOfStock_args()
2584 
    args.orderId = orderId
2585 
    args.write(self._oprot)
2586 
    self._oprot.writeMessageEnd()
2587 
    self._oprot.trans.flush()
2588 
 
2589 
  def recv_markOrderAsOutOfStock(self, ):
2590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2591 
    if mtype == TMessageType.EXCEPTION:
2592 
      x = TApplicationException()
2593 
      x.read(self._iprot)
2594 
      self._iprot.readMessageEnd()
2595 
      raise x
2596 
    result = markOrderAsOutOfStock_result()
2597 
    result.read(self._iprot)
2598 
    self._iprot.readMessageEnd()
3431 rajveer 2599 
    if result.success is not None:
1208 chandransh 2600 
      return result.success
3431 rajveer 2601 
    if result.ex is not None:
1208 chandransh 2602 
      raise result.ex
2603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2604 
 
3064 chandransh 2605 
  def verifyOrder(self, orderId):
759 chandransh 2606 
    """
3064 chandransh 2607 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2608 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2609 
    used for all other orders as well.
2610 
    Throws an exception if no such order exists.
3431 rajveer 2611 
 
759 chandransh 2612 
    Parameters:
3064 chandransh 2613 
     - orderId
759 chandransh 2614 
    """
3064 chandransh 2615 
    self.send_verifyOrder(orderId)
2616 
    return self.recv_verifyOrder()
759 chandransh 2617 
 
3064 chandransh 2618 
  def send_verifyOrder(self, orderId):
2619 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2620 
    args = verifyOrder_args()
2621 
    args.orderId = orderId
759 chandransh 2622 
    args.write(self._oprot)
2623 
    self._oprot.writeMessageEnd()
2624 
    self._oprot.trans.flush()
2625 
 
3064 chandransh 2626 
  def recv_verifyOrder(self, ):
759 chandransh 2627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2628 
    if mtype == TMessageType.EXCEPTION:
2629 
      x = TApplicationException()
2630 
      x.read(self._iprot)
2631 
      self._iprot.readMessageEnd()
2632 
      raise x
3064 chandransh 2633 
    result = verifyOrder_result()
759 chandransh 2634 
    result.read(self._iprot)
2635 
    self._iprot.readMessageEnd()
3431 rajveer 2636 
    if result.success is not None:
759 chandransh 2637 
      return result.success
3431 rajveer 2638 
    if result.ex is not None:
759 chandransh 2639 
      raise result.ex
3064 chandransh 2640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2641 
 
3064 chandransh 2642 
  def acceptOrder(self, orderId):
1113 chandransh 2643 
    """
3064 chandransh 2644 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2645 
    given order is not a COD order, it also captures the payment if the same has
2646 
    not been captured.
2647 
    Throws an exception if no such order exists.
3431 rajveer 2648 
 
1113 chandransh 2649 
    Parameters:
3064 chandransh 2650 
     - orderId
1113 chandransh 2651 
    """
3064 chandransh 2652 
    self.send_acceptOrder(orderId)
2653 
    return self.recv_acceptOrder()
1113 chandransh 2654 
 
3064 chandransh 2655 
  def send_acceptOrder(self, orderId):
2656 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2657 
    args = acceptOrder_args()
2658 
    args.orderId = orderId
1113 chandransh 2659 
    args.write(self._oprot)
2660 
    self._oprot.writeMessageEnd()
2661 
    self._oprot.trans.flush()
2662 
 
3064 chandransh 2663 
  def recv_acceptOrder(self, ):
1113 chandransh 2664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2665 
    if mtype == TMessageType.EXCEPTION:
2666 
      x = TApplicationException()
2667 
      x.read(self._iprot)
2668 
      self._iprot.readMessageEnd()
2669 
      raise x
3064 chandransh 2670 
    result = acceptOrder_result()
1113 chandransh 2671 
    result.read(self._iprot)
2672 
    self._iprot.readMessageEnd()
3431 rajveer 2673 
    if result.success is not None:
1113 chandransh 2674 
      return result.success
3431 rajveer 2675 
    if result.ex is not None:
1113 chandransh 2676 
      raise result.ex
3064 chandransh 2677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2678 
 
5110 mandeep.dh 2679 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2680 
    """
3064 chandransh 2681 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2682 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2683 
    the IMEI no. if a -1 is supplied.
2684 
    Also, it generates an invoice number for the order, marks the order as
2685 
    BILLED and sets the billing timestamp.
2686 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2687 
 
1135 chandransh 2688 
    Parameters:
3064 chandransh 2689 
     - orderId
2690 
     - invoice_number
4658 mandeep.dh 2691 
     - serialNumber
4283 anupam.sin 2692 
     - itemNumber
3064 chandransh 2693 
     - billed_by
4264 rajveer 2694 
     - jacketNumber
4283 anupam.sin 2695 
     - billingType
5110 mandeep.dh 2696 
     - fulfilmentWarehouseId
4763 rajveer 2697 
     - authorize
1135 chandransh 2698 
    """
5110 mandeep.dh 2699 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2700 
    return self.recv_addBillingDetails()
1135 chandransh 2701 
 
5110 mandeep.dh 2702 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2703 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2704 
    args = addBillingDetails_args()
2705 
    args.orderId = orderId
2706 
    args.invoice_number = invoice_number
4658 mandeep.dh 2707 
    args.serialNumber = serialNumber
4283 anupam.sin 2708 
    args.itemNumber = itemNumber
3064 chandransh 2709 
    args.billed_by = billed_by
4264 rajveer 2710 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2711 
    args.billingType = billingType
5110 mandeep.dh 2712 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2713 
    args.authorize = authorize
1135 chandransh 2714 
    args.write(self._oprot)
2715 
    self._oprot.writeMessageEnd()
2716 
    self._oprot.trans.flush()
2717 
 
3064 chandransh 2718 
  def recv_addBillingDetails(self, ):
1135 chandransh 2719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2720 
    if mtype == TMessageType.EXCEPTION:
2721 
      x = TApplicationException()
2722 
      x.read(self._iprot)
2723 
      self._iprot.readMessageEnd()
2724 
      raise x
3064 chandransh 2725 
    result = addBillingDetails_result()
1135 chandransh 2726 
    result.read(self._iprot)
2727 
    self._iprot.readMessageEnd()
3431 rajveer 2728 
    if result.success is not None:
3064 chandransh 2729 
      return result.success
3431 rajveer 2730 
    if result.ex is not None:
1135 chandransh 2731 
      raise result.ex
3064 chandransh 2732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2733 
 
6756 amar.kumar 2734 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2735 
    """
2736 
    Add the invoice number to the order.
2737 
 
2738 
    Parameters:
2739 
     - orderId
2740 
     - invoiceNumber
4763 rajveer 2741 
     - color
6756 amar.kumar 2742 
     - serialNumber
2743 
     - itemNumber
4579 rajveer 2744 
    """
6756 amar.kumar 2745 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2746 
    self.recv_addInvoiceNumber()
2747 
 
6756 amar.kumar 2748 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2749 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2750 
    args = addInvoiceNumber_args()
2751 
    args.orderId = orderId
2752 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2753 
    args.color = color
6756 amar.kumar 2754 
    args.serialNumber = serialNumber
2755 
    args.itemNumber = itemNumber
4579 rajveer 2756 
    args.write(self._oprot)
2757 
    self._oprot.writeMessageEnd()
2758 
    self._oprot.trans.flush()
2759 
 
2760 
  def recv_addInvoiceNumber(self, ):
2761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2762 
    if mtype == TMessageType.EXCEPTION:
2763 
      x = TApplicationException()
2764 
      x.read(self._iprot)
2765 
      self._iprot.readMessageEnd()
2766 
      raise x
2767 
    result = addInvoiceNumber_result()
2768 
    result.read(self._iprot)
2769 
    self._iprot.readMessageEnd()
2770 
    if result.ex is not None:
2771 
      raise result.ex
2772 
    return
2773 
 
4910 phani.kuma 2774 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2775 
    """
3064 chandransh 2776 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2777 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2778 
 
1408 ankur.sing 2779 
    Parameters:
3064 chandransh 2780 
     - warehouseId
1408 ankur.sing 2781 
     - providerId
3064 chandransh 2782 
     - cod
4910 phani.kuma 2783 
     - orderIds
1408 ankur.sing 2784 
    """
4910 phani.kuma 2785 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2786 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2787 
 
4910 phani.kuma 2788 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2789 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2790 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2791 
    args.warehouseId = warehouseId
1408 ankur.sing 2792 
    args.providerId = providerId
3064 chandransh 2793 
    args.cod = cod
4910 phani.kuma 2794 
    args.orderIds = orderIds
1408 ankur.sing 2795 
    args.write(self._oprot)
2796 
    self._oprot.writeMessageEnd()
2797 
    self._oprot.trans.flush()
2798 
 
4910 phani.kuma 2799 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2801 
    if mtype == TMessageType.EXCEPTION:
2802 
      x = TApplicationException()
2803 
      x.read(self._iprot)
2804 
      self._iprot.readMessageEnd()
2805 
      raise x
4910 phani.kuma 2806 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2807 
    result.read(self._iprot)
2808 
    self._iprot.readMessageEnd()
3431 rajveer 2809 
    if result.success is not None:
1408 ankur.sing 2810 
      return result.success
3431 rajveer 2811 
    if result.ex is not None:
3064 chandransh 2812 
      raise result.ex
4910 phani.kuma 2813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2814 
 
5713 rajveer 2815 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2816 
    """
2817 
    Parameters:
2818 
     - providerId
2819 
     - orderIds
5713 rajveer 2820 
     - awbs
5676 rajveer 2821 
    """
5713 rajveer 2822 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2823 
    return self.recv_markOrdersAsReturnedFromStore()
2824 
 
5713 rajveer 2825 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2826 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2827 
    args = markOrdersAsReturnedFromStore_args()
2828 
    args.providerId = providerId
2829 
    args.orderIds = orderIds
5713 rajveer 2830 
    args.awbs = awbs
5676 rajveer 2831 
    args.write(self._oprot)
2832 
    self._oprot.writeMessageEnd()
2833 
    self._oprot.trans.flush()
2834 
 
2835 
  def recv_markOrdersAsReturnedFromStore(self, ):
2836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2837 
    if mtype == TMessageType.EXCEPTION:
2838 
      x = TApplicationException()
2839 
      x.read(self._iprot)
2840 
      self._iprot.readMessageEnd()
2841 
      raise x
2842 
    result = markOrdersAsReturnedFromStore_result()
2843 
    result.read(self._iprot)
2844 
    self._iprot.readMessageEnd()
2845 
    if result.success is not None:
2846 
      return result.success
2847 
    if result.ex is not None:
2848 
      raise result.ex
2849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2850 
 
4910 phani.kuma 2851 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2852 
    """
4910 phani.kuma 2853 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2854 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2855 
 
2856 
    Parameters:
2857 
     - providerId
4910 phani.kuma 2858 
     - pickupDetails
4410 rajveer 2859 
    """
4910 phani.kuma 2860 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2861 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2862 
 
4910 phani.kuma 2863 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2864 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2865 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2866 
    args.providerId = providerId
4910 phani.kuma 2867 
    args.pickupDetails = pickupDetails
4410 rajveer 2868 
    args.write(self._oprot)
2869 
    self._oprot.writeMessageEnd()
2870 
    self._oprot.trans.flush()
2871 
 
4910 phani.kuma 2872 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2874 
    if mtype == TMessageType.EXCEPTION:
2875 
      x = TApplicationException()
2876 
      x.read(self._iprot)
2877 
      self._iprot.readMessageEnd()
2878 
      raise x
4910 phani.kuma 2879 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2880 
    result.read(self._iprot)
2881 
    self._iprot.readMessageEnd()
2882 
    if result.ex is not None:
2883 
      raise result.ex
4910 phani.kuma 2884 
    return
4410 rajveer 2885 
 
4910 phani.kuma 2886 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2887 
    """
3064 chandransh 2888 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2889 
 
94 ashish 2890 
    Parameters:
3064 chandransh 2891 
     - providerId
304 ashish 2892 
    """
4910 phani.kuma 2893 
    self.send_getOrdersNotPickedUp(providerId)
2894 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2895 
 
4910 phani.kuma 2896 
  def send_getOrdersNotPickedUp(self, providerId):
2897 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2898 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2899 
    args.providerId = providerId
304 ashish 2900 
    args.write(self._oprot)
2901 
    self._oprot.writeMessageEnd()
2902 
    self._oprot.trans.flush()
2903 
 
4910 phani.kuma 2904 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2906 
    if mtype == TMessageType.EXCEPTION:
2907 
      x = TApplicationException()
2908 
      x.read(self._iprot)
2909 
      self._iprot.readMessageEnd()
2910 
      raise x
4910 phani.kuma 2911 
    result = getOrdersNotPickedUp_result()
304 ashish 2912 
    result.read(self._iprot)
2913 
    self._iprot.readMessageEnd()
3431 rajveer 2914 
    if result.success is not None:
304 ashish 2915 
      return result.success
4910 phani.kuma 2916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2917 
 
3064 chandransh 2918 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2919 
    """
3064 chandransh 2920 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2921 
    the name of the receiver.
2922 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2923 
 
304 ashish 2924 
    Parameters:
3064 chandransh 2925 
     - providerId
2926 
     - deliveredOrders
304 ashish 2927 
    """
3064 chandransh 2928 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2929 
    self.recv_markOrdersAsDelivered()
304 ashish 2930 
 
3064 chandransh 2931 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2932 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2933 
    args = markOrdersAsDelivered_args()
2934 
    args.providerId = providerId
2935 
    args.deliveredOrders = deliveredOrders
304 ashish 2936 
    args.write(self._oprot)
2937 
    self._oprot.writeMessageEnd()
2938 
    self._oprot.trans.flush()
2939 
 
3064 chandransh 2940 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2942 
    if mtype == TMessageType.EXCEPTION:
2943 
      x = TApplicationException()
2944 
      x.read(self._iprot)
2945 
      self._iprot.readMessageEnd()
2946 
      raise x
3064 chandransh 2947 
    result = markOrdersAsDelivered_result()
304 ashish 2948 
    result.read(self._iprot)
2949 
    self._iprot.readMessageEnd()
3431 rajveer 2950 
    if result.ex is not None:
3064 chandransh 2951 
      raise result.ex
304 ashish 2952 
    return
2953 
 
4910 phani.kuma 2954 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2955 
    """
4910 phani.kuma 2956 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2957 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2958 
 
3064 chandransh 2959 
    Parameters:
2960 
     - providerId
2961 
     - returnedOrders
1596 ankur.sing 2962 
    """
4910 phani.kuma 2963 
    self.send_markAsRTOrders(providerId, returnedOrders)
2964 
    self.recv_markAsRTOrders()
304 ashish 2965 
 
4910 phani.kuma 2966 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2967 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2968 
    args = markAsRTOrders_args()
3064 chandransh 2969 
    args.providerId = providerId
2970 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2971 
    args.write(self._oprot)
2972 
    self._oprot.writeMessageEnd()
2973 
    self._oprot.trans.flush()
2974 
 
4910 phani.kuma 2975 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2977 
    if mtype == TMessageType.EXCEPTION:
2978 
      x = TApplicationException()
2979 
      x.read(self._iprot)
2980 
      self._iprot.readMessageEnd()
2981 
      raise x
4910 phani.kuma 2982 
    result = markAsRTOrders_result()
1596 ankur.sing 2983 
    result.read(self._iprot)
2984 
    self._iprot.readMessageEnd()
3431 rajveer 2985 
    if result.ex is not None:
3064 chandransh 2986 
      raise result.ex
2987 
    return
1596 ankur.sing 2988 
 
4910 phani.kuma 2989 
  def getRTOrders(self, providerId):
2990 
    """
2991 
    Returns a list of orders that were returned by courier.
2992 
 
2993 
    Parameters:
2994 
     - providerId
2995 
    """
2996 
    self.send_getRTOrders(providerId)
2997 
    return self.recv_getRTOrders()
2998 
 
2999 
  def send_getRTOrders(self, providerId):
3000 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3001 
    args = getRTOrders_args()
3002 
    args.providerId = providerId
3003 
    args.write(self._oprot)
3004 
    self._oprot.writeMessageEnd()
3005 
    self._oprot.trans.flush()
3006 
 
3007 
  def recv_getRTOrders(self, ):
3008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3009 
    if mtype == TMessageType.EXCEPTION:
3010 
      x = TApplicationException()
3011 
      x.read(self._iprot)
3012 
      self._iprot.readMessageEnd()
3013 
      raise x
3014 
    result = getRTOrders_result()
3015 
    result.read(self._iprot)
3016 
    self._iprot.readMessageEnd()
3017 
    if result.success is not None:
3018 
      return result.success
3019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3020 
 
3064 chandransh 3021 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3022 
    """
3064 chandransh 3023 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3024 
 
3064 chandransh 3025 
    Parameters:
3026 
     - providerId
3027 
     - undeliveredOrders
1627 ankur.sing 3028 
    """
3064 chandransh 3029 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3030 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3031 
 
3064 chandransh 3032 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3033 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3034 
    args = updateNonDeliveryReason_args()
3035 
    args.providerId = providerId
3036 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3037 
    args.write(self._oprot)
3038 
    self._oprot.writeMessageEnd()
3039 
    self._oprot.trans.flush()
3040 
 
3064 chandransh 3041 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3043 
    if mtype == TMessageType.EXCEPTION:
3044 
      x = TApplicationException()
3045 
      x.read(self._iprot)
3046 
      self._iprot.readMessageEnd()
3047 
      raise x
3064 chandransh 3048 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3049 
    result.read(self._iprot)
3050 
    self._iprot.readMessageEnd()
4910 phani.kuma 3051 
    if result.ex is not None:
3052 
      raise result.ex
3053 
    return
3054 
 
3055 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3056 
    """
3057 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3058 
 
3059 
    Parameters:
3060 
     - providerId
3061 
    """
3062 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3063 
    return self.recv_getNonDeliveredOrdersbyCourier()
3064 
 
3065 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3066 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3067 
    args = getNonDeliveredOrdersbyCourier_args()
3068 
    args.providerId = providerId
3069 
    args.write(self._oprot)
3070 
    self._oprot.writeMessageEnd()
3071 
    self._oprot.trans.flush()
3072 
 
3073 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3075 
    if mtype == TMessageType.EXCEPTION:
3076 
      x = TApplicationException()
3077 
      x.read(self._iprot)
3078 
      self._iprot.readMessageEnd()
3079 
      raise x
3080 
    result = getNonDeliveredOrdersbyCourier_result()
3081 
    result.read(self._iprot)
3082 
    self._iprot.readMessageEnd()
4581 phani.kuma 3083 
    if result.success is not None:
3084 
      return result.success
4910 phani.kuma 3085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3086 
 
3087 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3088 
    """
3089 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3090 
 
3091 
    Parameters:
3092 
     - providerId
3093 
     - local_connected_orders
3094 
    """
3095 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3096 
    self.recv_markOrdersAsLocalConnected()
3097 
 
3098 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3099 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3100 
    args = markOrdersAsLocalConnected_args()
3101 
    args.providerId = providerId
3102 
    args.local_connected_orders = local_connected_orders
3103 
    args.write(self._oprot)
3104 
    self._oprot.writeMessageEnd()
3105 
    self._oprot.trans.flush()
3106 
 
3107 
  def recv_markOrdersAsLocalConnected(self, ):
3108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3109 
    if mtype == TMessageType.EXCEPTION:
3110 
      x = TApplicationException()
3111 
      x.read(self._iprot)
3112 
      self._iprot.readMessageEnd()
3113 
      raise x
3114 
    result = markOrdersAsLocalConnected_result()
3115 
    result.read(self._iprot)
3116 
    self._iprot.readMessageEnd()
3431 rajveer 3117 
    if result.ex is not None:
3064 chandransh 3118 
      raise result.ex
4910 phani.kuma 3119 
    return
1627 ankur.sing 3120 
 
4910 phani.kuma 3121 
  def getOrdersNotLocalConnected(self, providerId):
3122 
    """
3123 
    Returns a list of orders that were picked up or shipped but pending local connection.
3124 
 
3125 
    Parameters:
3126 
     - providerId
3127 
    """
3128 
    self.send_getOrdersNotLocalConnected(providerId)
3129 
    return self.recv_getOrdersNotLocalConnected()
3130 
 
3131 
  def send_getOrdersNotLocalConnected(self, providerId):
3132 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3133 
    args = getOrdersNotLocalConnected_args()
3134 
    args.providerId = providerId
3135 
    args.write(self._oprot)
3136 
    self._oprot.writeMessageEnd()
3137 
    self._oprot.trans.flush()
3138 
 
3139 
  def recv_getOrdersNotLocalConnected(self, ):
3140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3141 
    if mtype == TMessageType.EXCEPTION:
3142 
      x = TApplicationException()
3143 
      x.read(self._iprot)
3144 
      self._iprot.readMessageEnd()
3145 
      raise x
3146 
    result = getOrdersNotLocalConnected_result()
3147 
    result.read(self._iprot)
3148 
    self._iprot.readMessageEnd()
3149 
    if result.success is not None:
3150 
      return result.success
3151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3152 
 
3153 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3154 
    """
3155 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3156 
 
3157 
    Parameters:
3158 
     - providerId
3159 
     - destination_city_reached_orders
3160 
    """
3161 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3162 
    self.recv_markOrdersAsDestinationCityReached()
3163 
 
3164 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3165 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3166 
    args = markOrdersAsDestinationCityReached_args()
3167 
    args.providerId = providerId
3168 
    args.destination_city_reached_orders = destination_city_reached_orders
3169 
    args.write(self._oprot)
3170 
    self._oprot.writeMessageEnd()
3171 
    self._oprot.trans.flush()
3172 
 
3173 
  def recv_markOrdersAsDestinationCityReached(self, ):
3174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3175 
    if mtype == TMessageType.EXCEPTION:
3176 
      x = TApplicationException()
3177 
      x.read(self._iprot)
3178 
      self._iprot.readMessageEnd()
3179 
      raise x
3180 
    result = markOrdersAsDestinationCityReached_result()
3181 
    result.read(self._iprot)
3182 
    self._iprot.readMessageEnd()
3183 
    if result.ex is not None:
3184 
      raise result.ex
3185 
    return
3186 
 
3187 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3188 
    """
3189 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3190 
 
3191 
    Parameters:
3192 
     - providerId
3193 
     - first_atdl_orders
3194 
    """
3195 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3196 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3197 
 
3198 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3199 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3200 
    args = markOrdersAsFirstDeliveryAttempted_args()
3201 
    args.providerId = providerId
3202 
    args.first_atdl_orders = first_atdl_orders
3203 
    args.write(self._oprot)
3204 
    self._oprot.writeMessageEnd()
3205 
    self._oprot.trans.flush()
3206 
 
3207 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3209 
    if mtype == TMessageType.EXCEPTION:
3210 
      x = TApplicationException()
3211 
      x.read(self._iprot)
3212 
      self._iprot.readMessageEnd()
3213 
      raise x
3214 
    result = markOrdersAsFirstDeliveryAttempted_result()
3215 
    result.read(self._iprot)
3216 
    self._iprot.readMessageEnd()
3217 
    if result.ex is not None:
3218 
      raise result.ex
3219 
    return
3220 
 
3064 chandransh 3221 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3222 
    """
3064 chandransh 3223 
    Returns the list of orders whose delivery time has passed but have not been
3224 
    delivered yet for the given provider and warehouse. To get a complete list of
3225 
    undelivered orders, pass them as -1.
3226 
    Returns an empty list if no such orders exist.
3431 rajveer 3227 
 
1886 ankur.sing 3228 
    Parameters:
3064 chandransh 3229 
     - providerId
3230 
     - warehouseId
1886 ankur.sing 3231 
    """
3064 chandransh 3232 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3233 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3234 
 
3064 chandransh 3235 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3236 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3237 
    args = getUndeliveredOrders_args()
3238 
    args.providerId = providerId
3239 
    args.warehouseId = warehouseId
1886 ankur.sing 3240 
    args.write(self._oprot)
3241 
    self._oprot.writeMessageEnd()
3242 
    self._oprot.trans.flush()
3243 
 
3064 chandransh 3244 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3246 
    if mtype == TMessageType.EXCEPTION:
3247 
      x = TApplicationException()
3248 
      x.read(self._iprot)
3249 
      self._iprot.readMessageEnd()
3250 
      raise x
3064 chandransh 3251 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3252 
    result.read(self._iprot)
3253 
    self._iprot.readMessageEnd()
3431 rajveer 3254 
    if result.success is not None:
1886 ankur.sing 3255 
      return result.success
3064 chandransh 3256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3257 
 
4783 phani.kuma 3258 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3259 
    """
3260 
    Returns the list of orders whose expected delivery date has passed but have not been
3261 
    delivered yet.
3262 
    Returns an empty list if no such orders exist.
3263 
    """
3264 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3265 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3266 
 
3267 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3268 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3269 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3270 
    args.write(self._oprot)
3271 
    self._oprot.writeMessageEnd()
3272 
    self._oprot.trans.flush()
3273 
 
3274 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3276 
    if mtype == TMessageType.EXCEPTION:
3277 
      x = TApplicationException()
3278 
      x.read(self._iprot)
3279 
      self._iprot.readMessageEnd()
3280 
      raise x
3281 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3282 
    result.read(self._iprot)
3283 
    self._iprot.readMessageEnd()
3284 
    if result.success is not None:
3285 
      return result.success
3286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3287 
 
2536 chandransh 3288 
  def toggleDOAFlag(self, orderId):
3289 
    """
3290 
    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.
3291 
    Returns the final flag status.
3292 
    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 3293 
 
2536 chandransh 3294 
    Parameters:
3295 
     - orderId
3296 
    """
3297 
    self.send_toggleDOAFlag(orderId)
3298 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3299 
 
2536 chandransh 3300 
  def send_toggleDOAFlag(self, orderId):
3301 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3302 
    args = toggleDOAFlag_args()
3303 
    args.orderId = orderId
3304 
    args.write(self._oprot)
3305 
    self._oprot.writeMessageEnd()
3306 
    self._oprot.trans.flush()
3307 
 
3308 
  def recv_toggleDOAFlag(self, ):
3309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3310 
    if mtype == TMessageType.EXCEPTION:
3311 
      x = TApplicationException()
3312 
      x.read(self._iprot)
3313 
      self._iprot.readMessageEnd()
3314 
      raise x
3315 
    result = toggleDOAFlag_result()
3316 
    result.read(self._iprot)
3317 
    self._iprot.readMessageEnd()
3431 rajveer 3318 
    if result.success is not None:
2536 chandransh 3319 
      return result.success
3431 rajveer 3320 
    if result.ex is not None:
2536 chandransh 3321 
      raise result.ex
3322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3323 
 
4712 rajveer 3324 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3325 
    """
3326 
    Parameters:
3327 
     - orderId
3328 
     - deliveryTimestamp
3329 
     - receiver
3330 
    """
3331 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3332 
    self.recv_markOrderAsDelivered()
3333 
 
3334 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3335 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3336 
    args = markOrderAsDelivered_args()
3337 
    args.orderId = orderId
3338 
    args.deliveryTimestamp = deliveryTimestamp
3339 
    args.receiver = receiver
3340 
    args.write(self._oprot)
3341 
    self._oprot.writeMessageEnd()
3342 
    self._oprot.trans.flush()
3343 
 
3344 
  def recv_markOrderAsDelivered(self, ):
3345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3346 
    if mtype == TMessageType.EXCEPTION:
3347 
      x = TApplicationException()
3348 
      x.read(self._iprot)
3349 
      self._iprot.readMessageEnd()
3350 
      raise x
3351 
    result = markOrderAsDelivered_result()
3352 
    result.read(self._iprot)
3353 
    self._iprot.readMessageEnd()
3354 
    if result.ex is not None:
3355 
      raise result.ex
3356 
    return
3357 
 
5553 rajveer 3358 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3359 
    """
3360 
    Parameters:
3361 
     - orderId
3362 
     - deliveryTimestamp
3363 
    """
3364 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3365 
    self.recv_markOrderAsReceivedAtStore()
3366 
 
3367 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3368 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3369 
    args = markOrderAsReceivedAtStore_args()
3370 
    args.orderId = orderId
3371 
    args.deliveryTimestamp = deliveryTimestamp
3372 
    args.write(self._oprot)
3373 
    self._oprot.writeMessageEnd()
3374 
    self._oprot.trans.flush()
3375 
 
3376 
  def recv_markOrderAsReceivedAtStore(self, ):
3377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3378 
    if mtype == TMessageType.EXCEPTION:
3379 
      x = TApplicationException()
3380 
      x.read(self._iprot)
3381 
      self._iprot.readMessageEnd()
3382 
      raise x
3383 
    result = markOrderAsReceivedAtStore_result()
3384 
    result.read(self._iprot)
3385 
    self._iprot.readMessageEnd()
3386 
    if result.ex is not None:
3387 
      raise result.ex
3388 
    return
3389 
 
4454 rajveer 3390 
  def markOrderDoaRequestReceived(self, orderId):
3391 
    """
3392 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3393 
 
3394 
    Parameters:
3395 
     - orderId
3396 
    """
3397 
    self.send_markOrderDoaRequestReceived(orderId)
3398 
    return self.recv_markOrderDoaRequestReceived()
3399 
 
3400 
  def send_markOrderDoaRequestReceived(self, orderId):
3401 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3402 
    args = markOrderDoaRequestReceived_args()
3403 
    args.orderId = orderId
3404 
    args.write(self._oprot)
3405 
    self._oprot.writeMessageEnd()
3406 
    self._oprot.trans.flush()
3407 
 
3408 
  def recv_markOrderDoaRequestReceived(self, ):
3409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3410 
    if mtype == TMessageType.EXCEPTION:
3411 
      x = TApplicationException()
3412 
      x.read(self._iprot)
3413 
      self._iprot.readMessageEnd()
3414 
      raise x
3415 
    result = markOrderDoaRequestReceived_result()
3416 
    result.read(self._iprot)
3417 
    self._iprot.readMessageEnd()
3418 
    if result.success is not None:
3419 
      return result.success
3420 
    if result.ex is not None:
3421 
      raise result.ex
3422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3423 
 
3424 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3425 
    """
3426 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3427 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3428 
 
3429 
    Parameters:
3430 
     - orderId
3431 
     - isAuthorized
3432 
    """
3433 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3434 
    return self.recv_markOrderDoaRequestAuthorized()
3435 
 
3436 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3437 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3438 
    args = markOrderDoaRequestAuthorized_args()
3439 
    args.orderId = orderId
3440 
    args.isAuthorized = isAuthorized
3441 
    args.write(self._oprot)
3442 
    self._oprot.writeMessageEnd()
3443 
    self._oprot.trans.flush()
3444 
 
3445 
  def recv_markOrderDoaRequestAuthorized(self, ):
3446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3447 
    if mtype == TMessageType.EXCEPTION:
3448 
      x = TApplicationException()
3449 
      x.read(self._iprot)
3450 
      self._iprot.readMessageEnd()
3451 
      raise x
3452 
    result = markOrderDoaRequestAuthorized_result()
3453 
    result.read(self._iprot)
3454 
    self._iprot.readMessageEnd()
3455 
    if result.success is not None:
3456 
      return result.success
3457 
    if result.ex is not None:
3458 
      raise result.ex
3459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3460 
 
4488 rajveer 3461 
  def markOrderReturnRequestReceived(self, orderId):
3462 
    """
3463 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3464 
 
3465 
    Parameters:
3466 
     - orderId
3467 
    """
3468 
    self.send_markOrderReturnRequestReceived(orderId)
3469 
    return self.recv_markOrderReturnRequestReceived()
3470 
 
3471 
  def send_markOrderReturnRequestReceived(self, orderId):
3472 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3473 
    args = markOrderReturnRequestReceived_args()
3474 
    args.orderId = orderId
3475 
    args.write(self._oprot)
3476 
    self._oprot.writeMessageEnd()
3477 
    self._oprot.trans.flush()
3478 
 
3479 
  def recv_markOrderReturnRequestReceived(self, ):
3480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3481 
    if mtype == TMessageType.EXCEPTION:
3482 
      x = TApplicationException()
3483 
      x.read(self._iprot)
3484 
      self._iprot.readMessageEnd()
3485 
      raise x
3486 
    result = markOrderReturnRequestReceived_result()
3487 
    result.read(self._iprot)
3488 
    self._iprot.readMessageEnd()
3489 
    if result.success is not None:
3490 
      return result.success
3491 
    if result.ex is not None:
3492 
      raise result.ex
3493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3494 
 
3495 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3496 
    """
3497 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3498 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3499 
 
3500 
    Parameters:
3501 
     - orderId
3502 
     - isAuthorized
3503 
    """
3504 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3505 
    return self.recv_markOrderReturnRequestAuthorized()
3506 
 
3507 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3508 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3509 
    args = markOrderReturnRequestAuthorized_args()
3510 
    args.orderId = orderId
3511 
    args.isAuthorized = isAuthorized
3512 
    args.write(self._oprot)
3513 
    self._oprot.writeMessageEnd()
3514 
    self._oprot.trans.flush()
3515 
 
3516 
  def recv_markOrderReturnRequestAuthorized(self, ):
3517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3518 
    if mtype == TMessageType.EXCEPTION:
3519 
      x = TApplicationException()
3520 
      x.read(self._iprot)
3521 
      self._iprot.readMessageEnd()
3522 
      raise x
3523 
    result = markOrderReturnRequestAuthorized_result()
3524 
    result.read(self._iprot)
3525 
    self._iprot.readMessageEnd()
3526 
    if result.success is not None:
3527 
      return result.success
3528 
    if result.ex is not None:
3529 
      raise result.ex
3530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3531 
 
4579 rajveer 3532 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3533 
    """
3534 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3535 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3536 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3537 
    For any other status, it returns false.
3538 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3539 
 
2536 chandransh 3540 
    Parameters:
3541 
     - orderId
4579 rajveer 3542 
     - providerId
2536 chandransh 3543 
    """
4579 rajveer 3544 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3545 
    return self.recv_requestPickupNumber()
3546 
 
4579 rajveer 3547 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3548 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3549 
    args = requestPickupNumber_args()
3550 
    args.orderId = orderId
4579 rajveer 3551 
    args.providerId = providerId
2536 chandransh 3552 
    args.write(self._oprot)
3553 
    self._oprot.writeMessageEnd()
3554 
    self._oprot.trans.flush()
3555 
 
3556 
  def recv_requestPickupNumber(self, ):
3557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3558 
    if mtype == TMessageType.EXCEPTION:
3559 
      x = TApplicationException()
3560 
      x.read(self._iprot)
3561 
      self._iprot.readMessageEnd()
3562 
      raise x
3563 
    result = requestPickupNumber_result()
3564 
    result.read(self._iprot)
3565 
    self._iprot.readMessageEnd()
3431 rajveer 3566 
    if result.success is not None:
2536 chandransh 3567 
      return result.success
3431 rajveer 3568 
    if result.ex is not None:
2536 chandransh 3569 
      raise result.ex
3570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3571 
 
4602 rajveer 3572 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3573 
    """
4452 rajveer 3574 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3575 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3576 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3577 
    	3. Returns true
2591 chandransh 3578 
    If the order is in any other status, it returns false.
2536 chandransh 3579 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3580 
 
2536 chandransh 3581 
    Parameters:
3582 
     - orderId
3583 
     - pickupNumber
4602 rajveer 3584 
     - providerId
2536 chandransh 3585 
    """
4602 rajveer 3586 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3587 
    return self.recv_authorizePickup()
3588 
 
4602 rajveer 3589 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3590 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3591 
    args = authorizePickup_args()
3592 
    args.orderId = orderId
3593 
    args.pickupNumber = pickupNumber
4602 rajveer 3594 
    args.providerId = providerId
2536 chandransh 3595 
    args.write(self._oprot)
3596 
    self._oprot.writeMessageEnd()
3597 
    self._oprot.trans.flush()
3598 
 
3599 
  def recv_authorizePickup(self, ):
3600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3601 
    if mtype == TMessageType.EXCEPTION:
3602 
      x = TApplicationException()
3603 
      x.read(self._iprot)
3604 
      self._iprot.readMessageEnd()
3605 
      raise x
3606 
    result = authorizePickup_result()
3607 
    result.read(self._iprot)
3608 
    self._iprot.readMessageEnd()
3431 rajveer 3609 
    if result.success is not None:
2536 chandransh 3610 
      return result.success
3431 rajveer 3611 
    if result.ex is not None:
2536 chandransh 3612 
      raise result.ex
3613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3614 
 
2764 chandransh 3615 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3616 
    """
3617 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3618 
 
2764 chandransh 3619 
    Parameters:
3620 
     - providerId
3621 
     - pickupDetails
3622 
    """
3623 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3624 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3625 
 
3626 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3627 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3628 
    args = markDoasAsPickedUp_args()
3629 
    args.providerId = providerId
3630 
    args.pickupDetails = pickupDetails
3631 
    args.write(self._oprot)
3632 
    self._oprot.writeMessageEnd()
3633 
    self._oprot.trans.flush()
3634 
 
3635 
  def recv_markDoasAsPickedUp(self, ):
3636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3637 
    if mtype == TMessageType.EXCEPTION:
3638 
      x = TApplicationException()
3639 
      x.read(self._iprot)
3640 
      self._iprot.readMessageEnd()
3641 
      raise x
3642 
    result = markDoasAsPickedUp_result()
3643 
    result.read(self._iprot)
3644 
    self._iprot.readMessageEnd()
4910 phani.kuma 3645 
    return
3646 
 
3647 
  def getDoasNotPickedUp(self, providerId):
3648 
    """
3649 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3650 
 
3651 
    Parameters:
3652 
     - providerId
3653 
    """
3654 
    self.send_getDoasNotPickedUp(providerId)
3655 
    return self.recv_getDoasNotPickedUp()
3656 
 
3657 
  def send_getDoasNotPickedUp(self, providerId):
3658 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3659 
    args = getDoasNotPickedUp_args()
3660 
    args.providerId = providerId
3661 
    args.write(self._oprot)
3662 
    self._oprot.writeMessageEnd()
3663 
    self._oprot.trans.flush()
3664 
 
3665 
  def recv_getDoasNotPickedUp(self, ):
3666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3667 
    if mtype == TMessageType.EXCEPTION:
3668 
      x = TApplicationException()
3669 
      x.read(self._iprot)
3670 
      self._iprot.readMessageEnd()
3671 
      raise x
3672 
    result = getDoasNotPickedUp_result()
3673 
    result.read(self._iprot)
3674 
    self._iprot.readMessageEnd()
3431 rajveer 3675 
    if result.success is not None:
2764 chandransh 3676 
      return result.success
4910 phani.kuma 3677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3678 
 
4741 phani.kuma 3679 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3680 
    """
3681 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3682 
 
3683 
    Parameters:
3684 
     - providerId
3685 
     - pickupDetails
3686 
    """
3687 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3688 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3689 
 
3690 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3691 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3692 
    args = markReturnOrdersAsPickedUp_args()
3693 
    args.providerId = providerId
3694 
    args.pickupDetails = pickupDetails
3695 
    args.write(self._oprot)
3696 
    self._oprot.writeMessageEnd()
3697 
    self._oprot.trans.flush()
3698 
 
3699 
  def recv_markReturnOrdersAsPickedUp(self, ):
3700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3701 
    if mtype == TMessageType.EXCEPTION:
3702 
      x = TApplicationException()
3703 
      x.read(self._iprot)
3704 
      self._iprot.readMessageEnd()
3705 
      raise x
3706 
    result = markReturnOrdersAsPickedUp_result()
3707 
    result.read(self._iprot)
3708 
    self._iprot.readMessageEnd()
4910 phani.kuma 3709 
    return
3710 
 
3711 
  def getReturnOrdersNotPickedUp(self, providerId):
3712 
    """
3713 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3714 
 
3715 
    Parameters:
3716 
     - providerId
3717 
    """
3718 
    self.send_getReturnOrdersNotPickedUp(providerId)
3719 
    return self.recv_getReturnOrdersNotPickedUp()
3720 
 
3721 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3722 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3723 
    args = getReturnOrdersNotPickedUp_args()
3724 
    args.providerId = providerId
3725 
    args.write(self._oprot)
3726 
    self._oprot.writeMessageEnd()
3727 
    self._oprot.trans.flush()
3728 
 
3729 
  def recv_getReturnOrdersNotPickedUp(self, ):
3730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3731 
    if mtype == TMessageType.EXCEPTION:
3732 
      x = TApplicationException()
3733 
      x.read(self._iprot)
3734 
      self._iprot.readMessageEnd()
3735 
      raise x
3736 
    result = getReturnOrdersNotPickedUp_result()
3737 
    result.read(self._iprot)
3738 
    self._iprot.readMessageEnd()
4741 phani.kuma 3739 
    if result.success is not None:
3740 
      return result.success
4910 phani.kuma 3741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3742 
 
4479 rajveer 3743 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3744 
    """
4452 rajveer 3745 
    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 3746 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3747 
    If the order is in any other state, it returns false.
3748 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3749 
 
2591 chandransh 3750 
    Parameters:
3751 
     - orderId
4479 rajveer 3752 
     - receiveCondition
2591 chandransh 3753 
    """
4479 rajveer 3754 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3755 
    return self.recv_receiveReturn()
2536 chandransh 3756 
 
4479 rajveer 3757 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3758 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3759 
    args = receiveReturn_args()
2591 chandransh 3760 
    args.orderId = orderId
4479 rajveer 3761 
    args.receiveCondition = receiveCondition
2591 chandransh 3762 
    args.write(self._oprot)
3763 
    self._oprot.writeMessageEnd()
3764 
    self._oprot.trans.flush()
3765 
 
2616 chandransh 3766 
  def recv_receiveReturn(self, ):
2591 chandransh 3767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3768 
    if mtype == TMessageType.EXCEPTION:
3769 
      x = TApplicationException()
3770 
      x.read(self._iprot)
3771 
      self._iprot.readMessageEnd()
3772 
      raise x
2616 chandransh 3773 
    result = receiveReturn_result()
2591 chandransh 3774 
    result.read(self._iprot)
3775 
    self._iprot.readMessageEnd()
3431 rajveer 3776 
    if result.success is not None:
2591 chandransh 3777 
      return result.success
3431 rajveer 3778 
    if result.ex is not None:
2591 chandransh 3779 
      raise result.ex
2616 chandransh 3780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3781 
 
3782 
  def validateDoa(self, orderId, isValid):
3783 
    """
4452 rajveer 3784 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3785 
    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 3786 
    If the order is in any other state, it returns false.
3787 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3788 
 
2591 chandransh 3789 
    Parameters:
3790 
     - orderId
3791 
     - isValid
3792 
    """
3793 
    self.send_validateDoa(orderId, isValid)
3794 
    return self.recv_validateDoa()
3795 
 
3796 
  def send_validateDoa(self, orderId, isValid):
3797 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3798 
    args = validateDoa_args()
3799 
    args.orderId = orderId
3800 
    args.isValid = isValid
3801 
    args.write(self._oprot)
3802 
    self._oprot.writeMessageEnd()
3803 
    self._oprot.trans.flush()
3804 
 
3805 
  def recv_validateDoa(self, ):
3806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3807 
    if mtype == TMessageType.EXCEPTION:
3808 
      x = TApplicationException()
3809 
      x.read(self._iprot)
3810 
      self._iprot.readMessageEnd()
3811 
      raise x
3812 
    result = validateDoa_result()
3813 
    result.read(self._iprot)
3814 
    self._iprot.readMessageEnd()
3431 rajveer 3815 
    if result.success is not None:
2591 chandransh 3816 
      return result.success
3431 rajveer 3817 
    if result.ex is not None:
2591 chandransh 3818 
      raise result.ex
3819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3820 
 
4495 rajveer 3821 
  def validateReturnProduct(self, orderId, isUsable):
3822 
    """
3823 
    Parameters:
3824 
     - orderId
3825 
     - isUsable
3826 
    """
3827 
    self.send_validateReturnProduct(orderId, isUsable)
3828 
    return self.recv_validateReturnProduct()
3829 
 
3830 
  def send_validateReturnProduct(self, orderId, isUsable):
3831 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3832 
    args = validateReturnProduct_args()
3833 
    args.orderId = orderId
3834 
    args.isUsable = isUsable
3835 
    args.write(self._oprot)
3836 
    self._oprot.writeMessageEnd()
3837 
    self._oprot.trans.flush()
3838 
 
3839 
  def recv_validateReturnProduct(self, ):
3840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3841 
    if mtype == TMessageType.EXCEPTION:
3842 
      x = TApplicationException()
3843 
      x.read(self._iprot)
3844 
      self._iprot.readMessageEnd()
3845 
      raise x
3846 
    result = validateReturnProduct_result()
3847 
    result.read(self._iprot)
3848 
    self._iprot.readMessageEnd()
3849 
    if result.success is not None:
3850 
      return result.success
3851 
    if result.ex is not None:
3852 
      raise result.ex
3853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3854 
 
2616 chandransh 3855 
  def reshipOrder(self, orderId):
3856 
    """
4484 rajveer 3857 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3858 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3859 
    	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 3860 
 
3861 
    If the order is in DOA_CERT_VALID state, it does the following:
3862 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3863 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3864 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3865 
 
2616 chandransh 3866 
    Returns the id of the newly created order.
3431 rajveer 3867 
 
2616 chandransh 3868 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3869 
 
2616 chandransh 3870 
    Parameters:
3871 
     - orderId
3872 
    """
3873 
    self.send_reshipOrder(orderId)
3874 
    return self.recv_reshipOrder()
2591 chandransh 3875 
 
2616 chandransh 3876 
  def send_reshipOrder(self, orderId):
3877 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3878 
    args = reshipOrder_args()
3879 
    args.orderId = orderId
3880 
    args.write(self._oprot)
3881 
    self._oprot.writeMessageEnd()
3882 
    self._oprot.trans.flush()
3883 
 
3884 
  def recv_reshipOrder(self, ):
3885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3886 
    if mtype == TMessageType.EXCEPTION:
3887 
      x = TApplicationException()
3888 
      x.read(self._iprot)
3889 
      self._iprot.readMessageEnd()
3890 
      raise x
3891 
    result = reshipOrder_result()
3892 
    result.read(self._iprot)
3893 
    self._iprot.readMessageEnd()
3431 rajveer 3894 
    if result.success is not None:
2616 chandransh 3895 
      return result.success
3431 rajveer 3896 
    if result.ex is not None:
2616 chandransh 3897 
      raise result.ex
3898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3899 
 
3226 chandransh 3900 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3901 
    """
4484 rajveer 3902 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3903 
    	1. Creates a refund request for batch processing.
3904 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3905 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3906 
 
2616 chandransh 3907 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3908 
    	1. Creates a refund request for batch processing.
3226 chandransh 3909 
    	2. Cancels the reservation of the item in the warehouse.
3910 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3911 
 
3226 chandransh 3912 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3913 
    	1. Cancels the reservation of the item in the warehouse.
3914 
    	2. Marks the current order as CANCELED.
3915 
 
3916 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3917 
 
2616 chandransh 3918 
    Returns True if it is successful, False otherwise.
3431 rajveer 3919 
 
2616 chandransh 3920 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3921 
 
2616 chandransh 3922 
    Parameters:
3923 
     - orderId
3226 chandransh 3924 
     - refundedBy
3925 
     - reason
2616 chandransh 3926 
    """
3226 chandransh 3927 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3928 
    return self.recv_refundOrder()
3929 
 
3226 chandransh 3930 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3931 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3932 
    args = refundOrder_args()
3933 
    args.orderId = orderId
3226 chandransh 3934 
    args.refundedBy = refundedBy
3935 
    args.reason = reason
2616 chandransh 3936 
    args.write(self._oprot)
3937 
    self._oprot.writeMessageEnd()
3938 
    self._oprot.trans.flush()
3939 
 
3940 
  def recv_refundOrder(self, ):
3941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3942 
    if mtype == TMessageType.EXCEPTION:
3943 
      x = TApplicationException()
3944 
      x.read(self._iprot)
3945 
      self._iprot.readMessageEnd()
3946 
      raise x
3947 
    result = refundOrder_result()
3948 
    result.read(self._iprot)
3949 
    self._iprot.readMessageEnd()
3431 rajveer 3950 
    if result.success is not None:
2616 chandransh 3951 
      return result.success
3431 rajveer 3952 
    if result.ex is not None:
2616 chandransh 3953 
      raise result.ex
3954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3955 
 
2690 chandransh 3956 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3957 
    """
3958 
    Get all return orders created between the from and to dates for the given warehouse.
3959 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3960 
 
2690 chandransh 3961 
    Parameters:
3962 
     - warehouseId
3963 
     - fromDate
3964 
     - toDate
3965 
    """
3966 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3967 
    return self.recv_getReturnOrders()
2616 chandransh 3968 
 
2690 chandransh 3969 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3970 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3971 
    args = getReturnOrders_args()
3972 
    args.warehouseId = warehouseId
3973 
    args.fromDate = fromDate
3974 
    args.toDate = toDate
3975 
    args.write(self._oprot)
3976 
    self._oprot.writeMessageEnd()
3977 
    self._oprot.trans.flush()
3978 
 
3979 
  def recv_getReturnOrders(self, ):
3980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3981 
    if mtype == TMessageType.EXCEPTION:
3982 
      x = TApplicationException()
3983 
      x.read(self._iprot)
3984 
      self._iprot.readMessageEnd()
3985 
      raise x
3986 
    result = getReturnOrders_result()
3987 
    result.read(self._iprot)
3988 
    self._iprot.readMessageEnd()
3431 rajveer 3989 
    if result.success is not None:
2690 chandransh 3990 
      return result.success
3991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3992 
 
5481 phani.kuma 3993 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3994 
    """
3995 
    Get all return orders created between the from and to dates.
3996 
 
3997 
    Parameters:
3998 
     - onlyNotProcessed
3999 
     - fromDate
4000 
     - toDate
4001 
    """
4002 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4003 
    return self.recv_getAllReturnOrders()
4004 
 
4005 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4006 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4007 
    args = getAllReturnOrders_args()
4008 
    args.onlyNotProcessed = onlyNotProcessed
4009 
    args.fromDate = fromDate
4010 
    args.toDate = toDate
4011 
    args.write(self._oprot)
4012 
    self._oprot.writeMessageEnd()
4013 
    self._oprot.trans.flush()
4014 
 
4015 
  def recv_getAllReturnOrders(self, ):
4016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4017 
    if mtype == TMessageType.EXCEPTION:
4018 
      x = TApplicationException()
4019 
      x.read(self._iprot)
4020 
      self._iprot.readMessageEnd()
4021 
      raise x
4022 
    result = getAllReturnOrders_result()
4023 
    result.read(self._iprot)
4024 
    self._iprot.readMessageEnd()
4025 
    if result.success is not None:
4026 
      return result.success
4027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4028 
 
2700 chandransh 4029 
  def getReturnOrder(self, id):
4030 
    """
4031 
    Returns the ReturnOrder corresponding to the given id.
4032 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4033 
 
2700 chandransh 4034 
    Parameters:
4035 
     - id
4036 
    """
4037 
    self.send_getReturnOrder(id)
4038 
    return self.recv_getReturnOrder()
4039 
 
4040 
  def send_getReturnOrder(self, id):
4041 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4042 
    args = getReturnOrder_args()
4043 
    args.id = id
4044 
    args.write(self._oprot)
4045 
    self._oprot.writeMessageEnd()
4046 
    self._oprot.trans.flush()
4047 
 
4048 
  def recv_getReturnOrder(self, ):
4049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4050 
    if mtype == TMessageType.EXCEPTION:
4051 
      x = TApplicationException()
4052 
      x.read(self._iprot)
4053 
      self._iprot.readMessageEnd()
4054 
      raise x
4055 
    result = getReturnOrder_result()
4056 
    result.read(self._iprot)
4057 
    self._iprot.readMessageEnd()
3431 rajveer 4058 
    if result.success is not None:
2700 chandransh 4059 
      return result.success
3431 rajveer 4060 
    if result.ex is not None:
2700 chandransh 4061 
      raise result.ex
4062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4063 
 
2690 chandransh 4064 
  def processReturn(self, returnOrderId):
4065 
    """
4066 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4067 
 
2690 chandransh 4068 
    Parameters:
4069 
     - returnOrderId
4070 
    """
4071 
    self.send_processReturn(returnOrderId)
4072 
    self.recv_processReturn()
4073 
 
4074 
  def send_processReturn(self, returnOrderId):
4075 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4076 
    args = processReturn_args()
4077 
    args.returnOrderId = returnOrderId
4078 
    args.write(self._oprot)
4079 
    self._oprot.writeMessageEnd()
4080 
    self._oprot.trans.flush()
4081 
 
4082 
  def recv_processReturn(self, ):
4083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4084 
    if mtype == TMessageType.EXCEPTION:
4085 
      x = TApplicationException()
4086 
      x.read(self._iprot)
4087 
      self._iprot.readMessageEnd()
4088 
      raise x
4089 
    result = processReturn_result()
4090 
    result.read(self._iprot)
4091 
    self._iprot.readMessageEnd()
3431 rajveer 4092 
    if result.ex is not None:
2690 chandransh 4093 
      raise result.ex
4094 
    return
4095 
 
3451 chandransh 4096 
  def updateWeight(self, orderId, weight):
4097 
    """
4098 
    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 4099 
 
3451 chandransh 4100 
    Parameters:
4101 
     - orderId
4102 
     - weight
4103 
    """
4104 
    self.send_updateWeight(orderId, weight)
4105 
    return self.recv_updateWeight()
4106 
 
4107 
  def send_updateWeight(self, orderId, weight):
4108 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4109 
    args = updateWeight_args()
4110 
    args.orderId = orderId
4111 
    args.weight = weight
4112 
    args.write(self._oprot)
4113 
    self._oprot.writeMessageEnd()
4114 
    self._oprot.trans.flush()
4115 
 
4116 
  def recv_updateWeight(self, ):
4117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4118 
    if mtype == TMessageType.EXCEPTION:
4119 
      x = TApplicationException()
4120 
      x.read(self._iprot)
4121 
      self._iprot.readMessageEnd()
4122 
      raise x
4123 
    result = updateWeight_result()
4124 
    result.read(self._iprot)
4125 
    self._iprot.readMessageEnd()
4126 
    if result.success is not None:
4127 
      return result.success
4128 
    if result.ex is not None:
4129 
      raise result.ex
4130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4131 
 
3469 chandransh 4132 
  def changeItem(self, orderId, itemId):
4133 
    """
4134 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4135 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4136 
 
3469 chandransh 4137 
    Parameters:
4138 
     - orderId
4139 
     - itemId
4140 
    """
4141 
    self.send_changeItem(orderId, itemId)
4142 
    return self.recv_changeItem()
4143 
 
4144 
  def send_changeItem(self, orderId, itemId):
4145 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4146 
    args = changeItem_args()
4147 
    args.orderId = orderId
4148 
    args.itemId = itemId
4149 
    args.write(self._oprot)
4150 
    self._oprot.writeMessageEnd()
4151 
    self._oprot.trans.flush()
4152 
 
4153 
  def recv_changeItem(self, ):
4154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4155 
    if mtype == TMessageType.EXCEPTION:
4156 
      x = TApplicationException()
4157 
      x.read(self._iprot)
4158 
      self._iprot.readMessageEnd()
4159 
      raise x
4160 
    result = changeItem_result()
4161 
    result.read(self._iprot)
4162 
    self._iprot.readMessageEnd()
4163 
    if result.success is not None:
4164 
      return result.success
4165 
    if result.ex is not None:
4166 
      raise result.ex
4167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4168 
 
4169 
  def shiftToWarehouse(self, orderId, warehouseId):
4170 
    """
4171 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4172 
 
4173 
    Parameters:
4174 
     - orderId
4175 
     - warehouseId
4176 
    """
4177 
    self.send_shiftToWarehouse(orderId, warehouseId)
4178 
    return self.recv_shiftToWarehouse()
4179 
 
4180 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4181 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4182 
    args = shiftToWarehouse_args()
4183 
    args.orderId = orderId
4184 
    args.warehouseId = warehouseId
4185 
    args.write(self._oprot)
4186 
    self._oprot.writeMessageEnd()
4187 
    self._oprot.trans.flush()
4188 
 
4189 
  def recv_shiftToWarehouse(self, ):
4190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4191 
    if mtype == TMessageType.EXCEPTION:
4192 
      x = TApplicationException()
4193 
      x.read(self._iprot)
4194 
      self._iprot.readMessageEnd()
4195 
      raise x
4196 
    result = shiftToWarehouse_result()
4197 
    result.read(self._iprot)
4198 
    self._iprot.readMessageEnd()
4199 
    if result.success is not None:
4200 
      return result.success
4201 
    if result.ex is not None:
4202 
      raise result.ex
4203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4204 
 
4647 rajveer 4205 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4206 
    """
4207 
    Adds the given delay reason to the given order.
3986 chandransh 4208 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4209 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4210 
 
3553 chandransh 4211 
    Parameters:
4212 
     - orderId
4213 
     - delayReason
3986 chandransh 4214 
     - furtherDelay
4647 rajveer 4215 
     - delayReasonText
3553 chandransh 4216 
    """
4647 rajveer 4217 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4218 
    return self.recv_addDelayReason()
4219 
 
4647 rajveer 4220 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4221 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4222 
    args = addDelayReason_args()
4223 
    args.orderId = orderId
4224 
    args.delayReason = delayReason
3986 chandransh 4225 
    args.furtherDelay = furtherDelay
4647 rajveer 4226 
    args.delayReasonText = delayReasonText
3553 chandransh 4227 
    args.write(self._oprot)
4228 
    self._oprot.writeMessageEnd()
4229 
    self._oprot.trans.flush()
4230 
 
4231 
  def recv_addDelayReason(self, ):
4232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4233 
    if mtype == TMessageType.EXCEPTION:
4234 
      x = TApplicationException()
4235 
      x.read(self._iprot)
4236 
      self._iprot.readMessageEnd()
4237 
      raise x
4238 
    result = addDelayReason_result()
4239 
    result.read(self._iprot)
4240 
    self._iprot.readMessageEnd()
4241 
    if result.success is not None:
4242 
      return result.success
4243 
    if result.ex is not None:
4244 
      raise result.ex
4245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4246 
 
3956 chandransh 4247 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4248 
    """
4249 
    Marks the COD orders with given AWB nos. as having been processed.
4250 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4251 
 
3956 chandransh 4252 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4253 
    1. There is no order corresponding to an AWB number.
4254 
    2. The captured amount for a payment exceeds the total payment.
4255 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4256 
 
4257 
    Parameters:
4258 
     - collectedAmountMap
4259 
     - xferBy
4260 
     - xferTxnId
4261 
     - xferDate
4262 
    """
4263 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4264 
    return self.recv_reconcileCodCollection()
4265 
 
4266 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4267 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4268 
    args = reconcileCodCollection_args()
4269 
    args.collectedAmountMap = collectedAmountMap
4270 
    args.xferBy = xferBy
4271 
    args.xferTxnId = xferTxnId
4272 
    args.xferDate = xferDate
4273 
    args.write(self._oprot)
4274 
    self._oprot.writeMessageEnd()
4275 
    self._oprot.trans.flush()
4276 
 
4277 
  def recv_reconcileCodCollection(self, ):
4278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4279 
    if mtype == TMessageType.EXCEPTION:
4280 
      x = TApplicationException()
4281 
      x.read(self._iprot)
4282 
      self._iprot.readMessageEnd()
4283 
      raise x
4284 
    result = reconcileCodCollection_result()
4285 
    result.read(self._iprot)
4286 
    self._iprot.readMessageEnd()
4287 
    if result.success is not None:
4288 
      return result.success
4289 
    if result.ex is not None:
4290 
      raise result.ex
4291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4292 
 
4008 mandeep.dh 4293 
  def getTransactionsRequiringExtraProcessing(self, category):
4294 
    """
4065 mandeep.dh 4295 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4296 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4297 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4298 
 
4008 mandeep.dh 4299 
    Parameters:
4300 
     - category
4301 
    """
4302 
    self.send_getTransactionsRequiringExtraProcessing(category)
4303 
    return self.recv_getTransactionsRequiringExtraProcessing()
4304 
 
4305 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4306 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4307 
    args = getTransactionsRequiringExtraProcessing_args()
4308 
    args.category = category
4309 
    args.write(self._oprot)
4310 
    self._oprot.writeMessageEnd()
4311 
    self._oprot.trans.flush()
4312 
 
4313 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4315 
    if mtype == TMessageType.EXCEPTION:
4316 
      x = TApplicationException()
4317 
      x.read(self._iprot)
4318 
      self._iprot.readMessageEnd()
4319 
      raise x
4320 
    result = getTransactionsRequiringExtraProcessing_result()
4321 
    result.read(self._iprot)
4322 
    self._iprot.readMessageEnd()
4323 
    if result.success is not None:
4324 
      return result.success
4325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4326 
 
4327 
  def markTransactionAsProcessed(self, transactionId, category):
4328 
    """
4329 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4330 
    It essentially deletes the transaction id record for a particular
4331 
    processing type category (if present) from DB.
4332 
    This is currently used by CRM application.
4008 mandeep.dh 4333 
 
4334 
    Parameters:
4335 
     - transactionId
4336 
     - category
4337 
    """
4338 
    self.send_markTransactionAsProcessed(transactionId, category)
4339 
    self.recv_markTransactionAsProcessed()
4340 
 
4341 
  def send_markTransactionAsProcessed(self, transactionId, category):
4342 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4343 
    args = markTransactionAsProcessed_args()
4344 
    args.transactionId = transactionId
4345 
    args.category = category
4346 
    args.write(self._oprot)
4347 
    self._oprot.writeMessageEnd()
4348 
    self._oprot.trans.flush()
4349 
 
4350 
  def recv_markTransactionAsProcessed(self, ):
4351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4352 
    if mtype == TMessageType.EXCEPTION:
4353 
      x = TApplicationException()
4354 
      x.read(self._iprot)
4355 
      self._iprot.readMessageEnd()
4356 
      raise x
4357 
    result = markTransactionAsProcessed_result()
4358 
    result.read(self._iprot)
4359 
    self._iprot.readMessageEnd()
4360 
    return
4361 
 
4018 chandransh 4362 
  def getItemWiseRiskyOrdersCount(self, ):
4363 
    """
4364 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4365 
    is defined as one whose shipping date is about to expire.
4366 
    """
4367 
    self.send_getItemWiseRiskyOrdersCount()
4368 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4369 
 
4018 chandransh 4370 
  def send_getItemWiseRiskyOrdersCount(self, ):
4371 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4372 
    args = getItemWiseRiskyOrdersCount_args()
4373 
    args.write(self._oprot)
4374 
    self._oprot.writeMessageEnd()
4375 
    self._oprot.trans.flush()
4376 
 
4377 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4379 
    if mtype == TMessageType.EXCEPTION:
4380 
      x = TApplicationException()
4381 
      x.read(self._iprot)
4382 
      self._iprot.readMessageEnd()
4383 
      raise x
4384 
    result = getItemWiseRiskyOrdersCount_result()
4385 
    result.read(self._iprot)
4386 
    self._iprot.readMessageEnd()
4387 
    if result.success is not None:
4388 
      return result.success
4389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4390 
 
4295 varun.gupt 4391 
  def getOrdersForItemIds(self, itemIds):
4392 
    """
4393 
    Returns a list of all orders which have items with given id
4394 
 
4395 
    Parameters:
4396 
     - itemIds
4397 
    """
4398 
    self.send_getOrdersForItemIds(itemIds)
4399 
    return self.recv_getOrdersForItemIds()
4400 
 
4401 
  def send_getOrdersForItemIds(self, itemIds):
4402 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4403 
    args = getOrdersForItemIds_args()
4404 
    args.itemIds = itemIds
4405 
    args.write(self._oprot)
4406 
    self._oprot.writeMessageEnd()
4407 
    self._oprot.trans.flush()
4408 
 
4409 
  def recv_getOrdersForItemIds(self, ):
4410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4411 
    if mtype == TMessageType.EXCEPTION:
4412 
      x = TApplicationException()
4413 
      x.read(self._iprot)
4414 
      self._iprot.readMessageEnd()
4415 
      raise x
4416 
    result = getOrdersForItemIds_result()
4417 
    result.read(self._iprot)
4418 
    self._iprot.readMessageEnd()
4419 
    if result.success is not None:
4420 
      return result.success
4421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4422 
 
4247 rajveer 4423 
  def markOrderCancellationRequestReceived(self, orderId):
4424 
    """
4425 
    Mark order as cancellation request received. If customer sends request of cancellation of
4426 
    a particular order, this method will be called. It will just change status of the order
4427 
    depending on its current status. It also records the previous status, so that we can move
4428 
    back to that status if cancellation request is denied.
4018 chandransh 4429 
 
4247 rajveer 4430 
    Parameters:
4431 
     - orderId
4432 
    """
4433 
    self.send_markOrderCancellationRequestReceived(orderId)
4434 
    self.recv_markOrderCancellationRequestReceived()
4435 
 
4436 
  def send_markOrderCancellationRequestReceived(self, orderId):
4437 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4438 
    args = markOrderCancellationRequestReceived_args()
4439 
    args.orderId = orderId
4440 
    args.write(self._oprot)
4441 
    self._oprot.writeMessageEnd()
4442 
    self._oprot.trans.flush()
4443 
 
4444 
  def recv_markOrderCancellationRequestReceived(self, ):
4445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4446 
    if mtype == TMessageType.EXCEPTION:
4447 
      x = TApplicationException()
4448 
      x.read(self._iprot)
4449 
      self._iprot.readMessageEnd()
4450 
      raise x
4451 
    result = markOrderCancellationRequestReceived_result()
4452 
    result.read(self._iprot)
4453 
    self._iprot.readMessageEnd()
4454 
    if result.ex is not None:
4455 
      raise result.ex
4456 
    return
4457 
 
4458 
  def markOrderCancellationRequestConfirmed(self, orderId):
4459 
    """
4460 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4461 
    cancellation request confirmed. After this OM will be able to cancel the order.
4462 
 
4463 
    Parameters:
4464 
     - orderId
4465 
    """
4466 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4467 
    self.recv_markOrderCancellationRequestConfirmed()
4468 
 
4469 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4470 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4471 
    args = markOrderCancellationRequestConfirmed_args()
4472 
    args.orderId = orderId
4473 
    args.write(self._oprot)
4474 
    self._oprot.writeMessageEnd()
4475 
    self._oprot.trans.flush()
4476 
 
4477 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4479 
    if mtype == TMessageType.EXCEPTION:
4480 
      x = TApplicationException()
4481 
      x.read(self._iprot)
4482 
      self._iprot.readMessageEnd()
4483 
      raise x
4484 
    result = markOrderCancellationRequestConfirmed_result()
4485 
    result.read(self._iprot)
4486 
    self._iprot.readMessageEnd()
4487 
    if result.ex is not None:
4488 
      raise result.ex
4489 
    return
4490 
 
4491 
  def markOrderCancellationRequestDenied(self, orderId):
4492 
    """
4493 
    If we decide to not to cancel order, we will move the order ro previous status.
4494 
 
4495 
    Parameters:
4496 
     - orderId
4497 
    """
4498 
    self.send_markOrderCancellationRequestDenied(orderId)
4499 
    self.recv_markOrderCancellationRequestDenied()
4500 
 
4501 
  def send_markOrderCancellationRequestDenied(self, orderId):
4502 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4503 
    args = markOrderCancellationRequestDenied_args()
4504 
    args.orderId = orderId
4505 
    args.write(self._oprot)
4506 
    self._oprot.writeMessageEnd()
4507 
    self._oprot.trans.flush()
4508 
 
4509 
  def recv_markOrderCancellationRequestDenied(self, ):
4510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4511 
    if mtype == TMessageType.EXCEPTION:
4512 
      x = TApplicationException()
4513 
      x.read(self._iprot)
4514 
      self._iprot.readMessageEnd()
4515 
      raise x
4516 
    result = markOrderCancellationRequestDenied_result()
4517 
    result.read(self._iprot)
4518 
    self._iprot.readMessageEnd()
4519 
    if result.ex is not None:
4520 
      raise result.ex
4521 
    return
4522 
 
4258 rajveer 4523 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4524 
    """
4258 rajveer 4525 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4526 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4527 
 
4528 
    Parameters:
4258 rajveer 4529 
     - transactionId
4247 rajveer 4530 
    """
4258 rajveer 4531 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4532 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4533 
 
4258 rajveer 4534 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4535 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4536 
    args = markTransactionAsPaymentFlagRemoved_args()
4537 
    args.transactionId = transactionId
4247 rajveer 4538 
    args.write(self._oprot)
4539 
    self._oprot.writeMessageEnd()
4540 
    self._oprot.trans.flush()
4541 
 
4258 rajveer 4542 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4544 
    if mtype == TMessageType.EXCEPTION:
4545 
      x = TApplicationException()
4546 
      x.read(self._iprot)
4547 
      self._iprot.readMessageEnd()
4548 
      raise x
4258 rajveer 4549 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4550 
    result.read(self._iprot)
4551 
    self._iprot.readMessageEnd()
4552 
    if result.ex is not None:
4553 
      raise result.ex
4554 
    return
4555 
 
4259 anupam.sin 4556 
  def refundTransaction(self, transactionId, refundedBy, reason):
4557 
    """
4558 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4559 
    need to be cancelled
4247 rajveer 4560 
 
4259 anupam.sin 4561 
    Parameters:
4562 
     - transactionId
4563 
     - refundedBy
4564 
     - reason
4565 
    """
4566 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4567 
    self.recv_refundTransaction()
4568 
 
4569 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4570 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4571 
    args = refundTransaction_args()
4572 
    args.transactionId = transactionId
4573 
    args.refundedBy = refundedBy
4574 
    args.reason = reason
4575 
    args.write(self._oprot)
4576 
    self._oprot.writeMessageEnd()
4577 
    self._oprot.trans.flush()
4578 
 
4579 
  def recv_refundTransaction(self, ):
4580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4581 
    if mtype == TMessageType.EXCEPTION:
4582 
      x = TApplicationException()
4583 
      x.read(self._iprot)
4584 
      self._iprot.readMessageEnd()
4585 
      raise x
4586 
    result = refundTransaction_result()
4587 
    result.read(self._iprot)
4588 
    self._iprot.readMessageEnd()
4589 
    if result.ex is not None:
4590 
      raise result.ex
4591 
    return
4592 
 
4324 mandeep.dh 4593 
  def updateShipmentAddress(self, orderId, addressId):
4594 
    """
4595 
    Updates shipment address of an order. Delivery and shipping date estimates
4596 
    etc. are also updated here.
4597 
 
4598 
    Throws TransactionServiceException in case address change is not
4599 
    possible due to certain reasons such as new pincode in address is
4600 
    not serviceable etc.
4601 
 
4602 
    Parameters:
4603 
     - orderId
4604 
     - addressId
4605 
    """
4606 
    self.send_updateShipmentAddress(orderId, addressId)
4607 
    self.recv_updateShipmentAddress()
4608 
 
4609 
  def send_updateShipmentAddress(self, orderId, addressId):
4610 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4611 
    args = updateShipmentAddress_args()
4612 
    args.orderId = orderId
4613 
    args.addressId = addressId
4614 
    args.write(self._oprot)
4615 
    self._oprot.writeMessageEnd()
4616 
    self._oprot.trans.flush()
4617 
 
4618 
  def recv_updateShipmentAddress(self, ):
4619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4620 
    if mtype == TMessageType.EXCEPTION:
4621 
      x = TApplicationException()
4622 
      x.read(self._iprot)
4623 
      self._iprot.readMessageEnd()
4624 
      raise x
4625 
    result = updateShipmentAddress_result()
4626 
    result.read(self._iprot)
4627 
    self._iprot.readMessageEnd()
4628 
    if result.ex is not None:
4629 
      raise result.ex
4630 
    return
4631 
 
4285 rajveer 4632 
  def acceptOrdersForItemId(self, itemId, inventory):
4633 
    """
4634 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4635 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4636 
 
4285 rajveer 4637 
    Parameters:
4638 
     - itemId
4639 
     - inventory
4640 
    """
4641 
    self.send_acceptOrdersForItemId(itemId, inventory)
4642 
    return self.recv_acceptOrdersForItemId()
4643 
 
4644 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4645 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4646 
    args = acceptOrdersForItemId_args()
4647 
    args.itemId = itemId
4648 
    args.inventory = inventory
4649 
    args.write(self._oprot)
4650 
    self._oprot.writeMessageEnd()
4651 
    self._oprot.trans.flush()
4652 
 
4653 
  def recv_acceptOrdersForItemId(self, ):
4654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4655 
    if mtype == TMessageType.EXCEPTION:
4656 
      x = TApplicationException()
4657 
      x.read(self._iprot)
4658 
      self._iprot.readMessageEnd()
4659 
      raise x
4660 
    result = acceptOrdersForItemId_result()
4661 
    result.read(self._iprot)
4662 
    self._iprot.readMessageEnd()
4663 
    if result.success is not None:
4664 
      return result.success
4665 
    if result.ex is not None:
4666 
      raise result.ex
4667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4668 
 
4369 rajveer 4669 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4670 
    """
4671 
    Parameters:
4672 
     - vendorId
4673 
     - itemId
4674 
     - quantity
4675 
     - estimate
4369 rajveer 4676 
     - isReminder
4303 rajveer 4677 
    """
4369 rajveer 4678 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4679 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4680 
 
4369 rajveer 4681 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4682 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4683 
    args = markOrdersAsPORaised_args()
4684 
    args.vendorId = vendorId
4685 
    args.itemId = itemId
4686 
    args.quantity = quantity
4687 
    args.estimate = estimate
4369 rajveer 4688 
    args.isReminder = isReminder
4303 rajveer 4689 
    args.write(self._oprot)
4690 
    self._oprot.writeMessageEnd()
4691 
    self._oprot.trans.flush()
4692 
 
4693 
  def recv_markOrdersAsPORaised(self, ):
4694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4695 
    if mtype == TMessageType.EXCEPTION:
4696 
      x = TApplicationException()
4697 
      x.read(self._iprot)
4698 
      self._iprot.readMessageEnd()
4699 
      raise x
4700 
    result = markOrdersAsPORaised_result()
4701 
    result.read(self._iprot)
4702 
    self._iprot.readMessageEnd()
4703 
    if result.ex is not None:
4704 
      raise result.ex
4705 
    return
4706 
 
4369 rajveer 4707 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4708 
    """
4709 
    Parameters:
4710 
     - vendorId
4711 
     - itemId
4712 
     - quantity
4713 
     - estimate
4369 rajveer 4714 
     - isReminder
4303 rajveer 4715 
    """
4369 rajveer 4716 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4717 
    self.recv_markOrdersAsReversalInitiated()
4718 
 
4369 rajveer 4719 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4720 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4721 
    args = markOrdersAsReversalInitiated_args()
4722 
    args.vendorId = vendorId
4723 
    args.itemId = itemId
4724 
    args.quantity = quantity
4725 
    args.estimate = estimate
4369 rajveer 4726 
    args.isReminder = isReminder
4303 rajveer 4727 
    args.write(self._oprot)
4728 
    self._oprot.writeMessageEnd()
4729 
    self._oprot.trans.flush()
4730 
 
4731 
  def recv_markOrdersAsReversalInitiated(self, ):
4732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4733 
    if mtype == TMessageType.EXCEPTION:
4734 
      x = TApplicationException()
4735 
      x.read(self._iprot)
4736 
      self._iprot.readMessageEnd()
4737 
      raise x
4738 
    result = markOrdersAsReversalInitiated_result()
4739 
    result.read(self._iprot)
4740 
    self._iprot.readMessageEnd()
4741 
    if result.ex is not None:
4742 
      raise result.ex
4743 
    return
4744 
 
4369 rajveer 4745 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4746 
    """
4747 
    Parameters:
4748 
     - vendorId
4749 
     - itemId
4750 
     - quantity
4751 
     - estimate
4369 rajveer 4752 
     - isReminder
4303 rajveer 4753 
    """
4369 rajveer 4754 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4755 
    self.recv_markOrdersAsNotAvailabke()
4756 
 
4369 rajveer 4757 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4758 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4759 
    args = markOrdersAsNotAvailabke_args()
4760 
    args.vendorId = vendorId
4761 
    args.itemId = itemId
4762 
    args.quantity = quantity
4763 
    args.estimate = estimate
4369 rajveer 4764 
    args.isReminder = isReminder
4303 rajveer 4765 
    args.write(self._oprot)
4766 
    self._oprot.writeMessageEnd()
4767 
    self._oprot.trans.flush()
4768 
 
4769 
  def recv_markOrdersAsNotAvailabke(self, ):
4770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4771 
    if mtype == TMessageType.EXCEPTION:
4772 
      x = TApplicationException()
4773 
      x.read(self._iprot)
4774 
      self._iprot.readMessageEnd()
4775 
      raise x
4776 
    result = markOrdersAsNotAvailabke_result()
4777 
    result.read(self._iprot)
4778 
    self._iprot.readMessageEnd()
4779 
    if result.ex is not None:
4780 
      raise result.ex
4781 
    return
4782 
 
4369 rajveer 4783 
  def markOrdersAsTimeout(self, vendorId):
4784 
    """
4785 
    Parameters:
4786 
     - vendorId
4787 
    """
4788 
    self.send_markOrdersAsTimeout(vendorId)
4789 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4790 
 
4369 rajveer 4791 
  def send_markOrdersAsTimeout(self, vendorId):
4792 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4793 
    args = markOrdersAsTimeout_args()
4794 
    args.vendorId = vendorId
4795 
    args.write(self._oprot)
4796 
    self._oprot.writeMessageEnd()
4797 
    self._oprot.trans.flush()
4798 
 
4799 
  def recv_markOrdersAsTimeout(self, ):
4800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4801 
    if mtype == TMessageType.EXCEPTION:
4802 
      x = TApplicationException()
4803 
      x.read(self._iprot)
4804 
      self._iprot.readMessageEnd()
4805 
      raise x
4806 
    result = markOrdersAsTimeout_result()
4807 
    result.read(self._iprot)
4808 
    self._iprot.readMessageEnd()
4809 
    if result.success is not None:
4810 
      return result.success
4811 
    if result.ex is not None:
4812 
      raise result.ex
4813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4814 
 
4662 rajveer 4815 
  def markOrderAsLostInTransit(self, orderId):
4816 
    """
4817 
    Mark order as LOST_IN_TRANSIT
4818 
 
4819 
    Parameters:
4820 
     - orderId
4821 
    """
4822 
    self.send_markOrderAsLostInTransit(orderId)
4823 
    return self.recv_markOrderAsLostInTransit()
4824 
 
4825 
  def send_markOrderAsLostInTransit(self, orderId):
4826 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4827 
    args = markOrderAsLostInTransit_args()
4828 
    args.orderId = orderId
4829 
    args.write(self._oprot)
4830 
    self._oprot.writeMessageEnd()
4831 
    self._oprot.trans.flush()
4832 
 
4833 
  def recv_markOrderAsLostInTransit(self, ):
4834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4835 
    if mtype == TMessageType.EXCEPTION:
4836 
      x = TApplicationException()
4837 
      x.read(self._iprot)
4838 
      self._iprot.readMessageEnd()
4839 
      raise x
4840 
    result = markOrderAsLostInTransit_result()
4841 
    result.read(self._iprot)
4842 
    self._iprot.readMessageEnd()
4843 
    if result.success is not None:
4844 
      return result.success
4845 
    if result.ex is not None:
4846 
      raise result.ex
4847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4848 
 
4386 anupam.sin 4849 
  def getOrderForAwb(self, awb):
4850 
    """
4851 
    Returns the order corresponding to an AWB number
4369 rajveer 4852 
 
4386 anupam.sin 4853 
    Parameters:
4854 
     - awb
4855 
    """
4856 
    self.send_getOrderForAwb(awb)
4857 
    return self.recv_getOrderForAwb()
4858 
 
4859 
  def send_getOrderForAwb(self, awb):
4860 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4861 
    args = getOrderForAwb_args()
4862 
    args.awb = awb
4863 
    args.write(self._oprot)
4864 
    self._oprot.writeMessageEnd()
4865 
    self._oprot.trans.flush()
4866 
 
4867 
  def recv_getOrderForAwb(self, ):
4868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4869 
    if mtype == TMessageType.EXCEPTION:
4870 
      x = TApplicationException()
4871 
      x.read(self._iprot)
4872 
      self._iprot.readMessageEnd()
4873 
      raise x
4874 
    result = getOrderForAwb_result()
4875 
    result.read(self._iprot)
4876 
    self._iprot.readMessageEnd()
4877 
    if result.success is not None:
4878 
      return result.success
4879 
    if result.ex is not None:
4880 
      raise result.ex
4881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4882 
 
4910 phani.kuma 4883 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4884 
    """
4910 phani.kuma 4885 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4886 
 
4506 phani.kuma 4887 
    Parameters:
4888 
     - logistics_provider_id
4910 phani.kuma 4889 
     - order_status_list
4506 phani.kuma 4890 
    """
4910 phani.kuma 4891 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4892 
    return self.recv_getOrdersForProviderForStatus()
4893 
 
4910 phani.kuma 4894 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4895 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4896 
    args = getOrdersForProviderForStatus_args()
4897 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4898 
    args.order_status_list = order_status_list
4506 phani.kuma 4899 
    args.write(self._oprot)
4900 
    self._oprot.writeMessageEnd()
4901 
    self._oprot.trans.flush()
4902 
 
4903 
  def recv_getOrdersForProviderForStatus(self, ):
4904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4905 
    if mtype == TMessageType.EXCEPTION:
4906 
      x = TApplicationException()
4907 
      x.read(self._iprot)
4908 
      self._iprot.readMessageEnd()
4909 
      raise x
4910 
    result = getOrdersForProviderForStatus_result()
4911 
    result.read(self._iprot)
4912 
    self._iprot.readMessageEnd()
4913 
    if result.success is not None:
4914 
      return result.success
4915 
    if result.ex is not None:
4916 
      raise result.ex
4917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4918 
 
4600 varun.gupt 4919 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4920 
    """
4921 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4922 
 
4600 varun.gupt 4923 
    Parameters:
4924 
     - vendorId
4925 
     - billingDateFrom
4926 
     - billingDateTo
4927 
    """
4928 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4929 
    return self.recv_getBilledOrdersForVendor()
4930 
 
4931 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4932 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4933 
    args = getBilledOrdersForVendor_args()
4934 
    args.vendorId = vendorId
4935 
    args.billingDateFrom = billingDateFrom
4936 
    args.billingDateTo = billingDateTo
4937 
    args.write(self._oprot)
4938 
    self._oprot.writeMessageEnd()
4939 
    self._oprot.trans.flush()
4940 
 
4941 
  def recv_getBilledOrdersForVendor(self, ):
4942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4943 
    if mtype == TMessageType.EXCEPTION:
4944 
      x = TApplicationException()
4945 
      x.read(self._iprot)
4946 
      self._iprot.readMessageEnd()
4947 
      raise x
4948 
    result = getBilledOrdersForVendor_result()
4949 
    result.read(self._iprot)
4950 
    self._iprot.readMessageEnd()
4951 
    if result.success is not None:
4952 
      return result.success
4953 
    if result.ex is not None:
4954 
      raise result.ex
4955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4956 
 
4607 rajveer 4957 
  def getSlippedSippingDateOrders(self, ):
4958 
    self.send_getSlippedSippingDateOrders()
4959 
    return self.recv_getSlippedSippingDateOrders()
4960 
 
4961 
  def send_getSlippedSippingDateOrders(self, ):
4962 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4963 
    args = getSlippedSippingDateOrders_args()
4964 
    args.write(self._oprot)
4965 
    self._oprot.writeMessageEnd()
4966 
    self._oprot.trans.flush()
4967 
 
4968 
  def recv_getSlippedSippingDateOrders(self, ):
4969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4970 
    if mtype == TMessageType.EXCEPTION:
4971 
      x = TApplicationException()
4972 
      x.read(self._iprot)
4973 
      self._iprot.readMessageEnd()
4974 
      raise x
4975 
    result = getSlippedSippingDateOrders_result()
4976 
    result.read(self._iprot)
4977 
    self._iprot.readMessageEnd()
4978 
    if result.success is not None:
4979 
      return result.success
4980 
    if result.ex is not None:
4981 
      raise result.ex
4982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4983 
 
4709 rajveer 4984 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4985 
    """
4986 
    Parameters:
4987 
     - cancelDateFrom
4988 
     - cancelDateTo
4989 
    """
4990 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4991 
    return self.recv_getCancelledOrders()
4992 
 
4993 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4994 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4995 
    args = getCancelledOrders_args()
4996 
    args.cancelDateFrom = cancelDateFrom
4997 
    args.cancelDateTo = cancelDateTo
4998 
    args.write(self._oprot)
4999 
    self._oprot.writeMessageEnd()
5000 
    self._oprot.trans.flush()
5001 
 
5002 
  def recv_getCancelledOrders(self, ):
5003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5004 
    if mtype == TMessageType.EXCEPTION:
5005 
      x = TApplicationException()
5006 
      x.read(self._iprot)
5007 
      self._iprot.readMessageEnd()
5008 
      raise x
5009 
    result = getCancelledOrders_result()
5010 
    result.read(self._iprot)
5011 
    self._iprot.readMessageEnd()
5012 
    if result.success is not None:
5013 
      return result.success
5014 
    if result.ex is not None:
5015 
      raise result.ex
5016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5017 
 
4600 varun.gupt 5018 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5019 
    """
5020 
    Parameters:
5021 
     - mapAWBAndAmount
5022 
    """
5023 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5024 
    self.recv_saveBluedartSettlements()
5025 
 
5026 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5027 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5028 
    args = saveBluedartSettlements_args()
5029 
    args.mapAWBAndAmount = mapAWBAndAmount
5030 
    args.write(self._oprot)
5031 
    self._oprot.writeMessageEnd()
5032 
    self._oprot.trans.flush()
5033 
 
5034 
  def recv_saveBluedartSettlements(self, ):
5035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5036 
    if mtype == TMessageType.EXCEPTION:
5037 
      x = TApplicationException()
5038 
      x.read(self._iprot)
5039 
      self._iprot.readMessageEnd()
5040 
      raise x
5041 
    result = saveBluedartSettlements_result()
5042 
    result.read(self._iprot)
5043 
    self._iprot.readMessageEnd()
5044 
    if result.ex is not None:
5045 
      raise result.ex
5046 
    return
5047 
 
4905 varun.gupt 5048 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5049 
    """
5050 
    Parameters:
5051 
     - settlementDate
5052 
     - paymentGatewayId
4905 varun.gupt 5053 
     - referenceId
4600 varun.gupt 5054 
     - serviceTax
5055 
     - otherCharges
5056 
     - netCollection
5057 
    """
4905 varun.gupt 5058 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5059 
    self.recv_savePaymentSettlements()
5060 
 
4905 varun.gupt 5061 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5062 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5063 
    args = savePaymentSettlements_args()
5064 
    args.settlementDate = settlementDate
5065 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5066 
    args.referenceId = referenceId
4600 varun.gupt 5067 
    args.serviceTax = serviceTax
5068 
    args.otherCharges = otherCharges
5069 
    args.netCollection = netCollection
5070 
    args.write(self._oprot)
5071 
    self._oprot.writeMessageEnd()
5072 
    self._oprot.trans.flush()
5073 
 
5074 
  def recv_savePaymentSettlements(self, ):
5075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5076 
    if mtype == TMessageType.EXCEPTION:
5077 
      x = TApplicationException()
5078 
      x.read(self._iprot)
5079 
      self._iprot.readMessageEnd()
5080 
      raise x
5081 
    result = savePaymentSettlements_result()
5082 
    result.read(self._iprot)
5083 
    self._iprot.readMessageEnd()
5084 
    if result.ex is not None:
5085 
      raise result.ex
5086 
    return
5087 
 
5088 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5089 
    """
5090 
    Parameters:
5091 
     - settlementId
5092 
     - settlementDate
5093 
     - transactionDateFrom
5094 
     - transactionDateTo
5095 
     - amount
5096 
    """
5097 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5098 
    self.recv_saveEBSSettlementSummary()
5099 
 
5100 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5101 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5102 
    args = saveEBSSettlementSummary_args()
5103 
    args.settlementId = settlementId
5104 
    args.settlementDate = settlementDate
5105 
    args.transactionDateFrom = transactionDateFrom
5106 
    args.transactionDateTo = transactionDateTo
5107 
    args.amount = amount
5108 
    args.write(self._oprot)
5109 
    self._oprot.writeMessageEnd()
5110 
    self._oprot.trans.flush()
5111 
 
5112 
  def recv_saveEBSSettlementSummary(self, ):
5113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5114 
    if mtype == TMessageType.EXCEPTION:
5115 
      x = TApplicationException()
5116 
      x.read(self._iprot)
5117 
      self._iprot.readMessageEnd()
5118 
      raise x
5119 
    result = saveEBSSettlementSummary_result()
5120 
    result.read(self._iprot)
5121 
    self._iprot.readMessageEnd()
5122 
    if result.ex is not None:
5123 
      raise result.ex
5124 
    return
5125 
 
5386 phani.kuma 5126 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5127 
    """
5128 
    Parameters:
5189 varun.gupt 5129 
     - referenceId
5130 
     - isRefund
4600 varun.gupt 5131 
    """
5386 phani.kuma 5132 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5133 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5134 
 
5386 phani.kuma 5135 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5136 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5137 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5138 
    args.referenceId = referenceId
5139 
    args.isRefund = isRefund
4600 varun.gupt 5140 
    args.write(self._oprot)
5141 
    self._oprot.writeMessageEnd()
5142 
    self._oprot.trans.flush()
5143 
 
5386 phani.kuma 5144 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5146 
    if mtype == TMessageType.EXCEPTION:
5147 
      x = TApplicationException()
5148 
      x.read(self._iprot)
5149 
      self._iprot.readMessageEnd()
5150 
      raise x
5386 phani.kuma 5151 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5152 
    result.read(self._iprot)
5153 
    self._iprot.readMessageEnd()
5154 
    if result.success is not None:
5155 
      return result.success
5156 
    if result.ex is not None:
5157 
      raise result.ex
5386 phani.kuma 5158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5159 
 
5386 phani.kuma 5160 
  def getSettlementForCod(self, orderId, isRefund):
5161 
    """
5162 
    Parameters:
5163 
     - orderId
5164 
     - isRefund
5165 
    """
5166 
    self.send_getSettlementForCod(orderId, isRefund)
5167 
    return self.recv_getSettlementForCod()
5168 
 
5169 
  def send_getSettlementForCod(self, orderId, isRefund):
5170 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5171 
    args = getSettlementForCod_args()
5172 
    args.orderId = orderId
5173 
    args.isRefund = isRefund
5174 
    args.write(self._oprot)
5175 
    self._oprot.writeMessageEnd()
5176 
    self._oprot.trans.flush()
5177 
 
5178 
  def recv_getSettlementForCod(self, ):
5179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5180 
    if mtype == TMessageType.EXCEPTION:
5181 
      x = TApplicationException()
5182 
      x.read(self._iprot)
5183 
      self._iprot.readMessageEnd()
5184 
      raise x
5185 
    result = getSettlementForCod_result()
5186 
    result.read(self._iprot)
5187 
    self._iprot.readMessageEnd()
5188 
    if result.success is not None:
5189 
      return result.success
5190 
    if result.ex is not None:
5191 
      raise result.ex
5192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5193 
 
4600 varun.gupt 5194 
  def getEBSSettlementSummaries(self, ):
5195 
    self.send_getEBSSettlementSummaries()
5196 
    return self.recv_getEBSSettlementSummaries()
5197 
 
5198 
  def send_getEBSSettlementSummaries(self, ):
5199 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5200 
    args = getEBSSettlementSummaries_args()
5201 
    args.write(self._oprot)
5202 
    self._oprot.writeMessageEnd()
5203 
    self._oprot.trans.flush()
5204 
 
5205 
  def recv_getEBSSettlementSummaries(self, ):
5206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5207 
    if mtype == TMessageType.EXCEPTION:
5208 
      x = TApplicationException()
5209 
      x.read(self._iprot)
5210 
      self._iprot.readMessageEnd()
5211 
      raise x
5212 
    result = getEBSSettlementSummaries_result()
5213 
    result.read(self._iprot)
5214 
    self._iprot.readMessageEnd()
5215 
    if result.success is not None:
5216 
      return result.success
5217 
    if result.ex is not None:
5218 
      raise result.ex
5219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5220 
 
5221 
  def markEBSSettlementUploaded(self, settlementId):
5222 
    """
5223 
    Parameters:
5224 
     - settlementId
5225 
    """
5226 
    self.send_markEBSSettlementUploaded(settlementId)
5227 
    self.recv_markEBSSettlementUploaded()
5228 
 
5229 
  def send_markEBSSettlementUploaded(self, settlementId):
5230 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5231 
    args = markEBSSettlementUploaded_args()
5232 
    args.settlementId = settlementId
5233 
    args.write(self._oprot)
5234 
    self._oprot.writeMessageEnd()
5235 
    self._oprot.trans.flush()
5236 
 
5237 
  def recv_markEBSSettlementUploaded(self, ):
5238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5239 
    if mtype == TMessageType.EXCEPTION:
5240 
      x = TApplicationException()
5241 
      x.read(self._iprot)
5242 
      self._iprot.readMessageEnd()
5243 
      raise x
5244 
    result = markEBSSettlementUploaded_result()
5245 
    result.read(self._iprot)
5246 
    self._iprot.readMessageEnd()
5247 
    if result.ex is not None:
5248 
      raise result.ex
5249 
    return
5250 
 
5251 
  def getEBSSettlementDate(self, settlementId):
5252 
    """
5253 
    Parameters:
5254 
     - settlementId
5255 
    """
5256 
    self.send_getEBSSettlementDate(settlementId)
5257 
    return self.recv_getEBSSettlementDate()
5258 
 
5259 
  def send_getEBSSettlementDate(self, settlementId):
5260 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5261 
    args = getEBSSettlementDate_args()
5262 
    args.settlementId = settlementId
5263 
    args.write(self._oprot)
5264 
    self._oprot.writeMessageEnd()
5265 
    self._oprot.trans.flush()
5266 
 
5267 
  def recv_getEBSSettlementDate(self, ):
5268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5269 
    if mtype == TMessageType.EXCEPTION:
5270 
      x = TApplicationException()
5271 
      x.read(self._iprot)
5272 
      self._iprot.readMessageEnd()
5273 
      raise x
5274 
    result = getEBSSettlementDate_result()
5275 
    result.read(self._iprot)
5276 
    self._iprot.readMessageEnd()
5277 
    if result.success is not None:
5278 
      return result.success
5279 
    if result.ex is not None:
5280 
      raise result.ex
5281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5282 
 
4715 varun.gupt 5283 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5284 
    """
5285 
    Parameters:
5286 
     - settlementDateFrom
5287 
     - settlementDateTo
5288 
     - isRefund
5289 
    """
5290 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5291 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5292 
 
4715 varun.gupt 5293 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5294 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5295 
    args = getSettlementsByDate_args()
5296 
    args.settlementDateFrom = settlementDateFrom
5297 
    args.settlementDateTo = settlementDateTo
5298 
    args.isRefund = isRefund
5299 
    args.write(self._oprot)
5300 
    self._oprot.writeMessageEnd()
5301 
    self._oprot.trans.flush()
5302 
 
5303 
  def recv_getSettlementsByDate(self, ):
5304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5305 
    if mtype == TMessageType.EXCEPTION:
5306 
      x = TApplicationException()
5307 
      x.read(self._iprot)
5308 
      self._iprot.readMessageEnd()
5309 
      raise x
5310 
    result = getSettlementsByDate_result()
5311 
    result.read(self._iprot)
5312 
    self._iprot.readMessageEnd()
5313 
    if result.success is not None:
5314 
      return result.success
5315 
    if result.ex is not None:
5316 
      raise result.ex
5317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5318 
 
5319 
  def getReshippedOrderIds(self, orderIds):
5320 
    """
5321 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5322 
 
5323 
    Parameters:
5324 
     - orderIds
5325 
    """
5326 
    self.send_getReshippedOrderIds(orderIds)
5327 
    return self.recv_getReshippedOrderIds()
5328 
 
5329 
  def send_getReshippedOrderIds(self, orderIds):
5330 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5331 
    args = getReshippedOrderIds_args()
5332 
    args.orderIds = orderIds
5333 
    args.write(self._oprot)
5334 
    self._oprot.writeMessageEnd()
5335 
    self._oprot.trans.flush()
5336 
 
5337 
  def recv_getReshippedOrderIds(self, ):
5338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5339 
    if mtype == TMessageType.EXCEPTION:
5340 
      x = TApplicationException()
5341 
      x.read(self._iprot)
5342 
      self._iprot.readMessageEnd()
5343 
      raise x
5344 
    result = getReshippedOrderIds_result()
5345 
    result.read(self._iprot)
5346 
    self._iprot.readMessageEnd()
5347 
    if result.success is not None:
5348 
      return result.success
5349 
    if result.ex is not None:
5350 
      raise result.ex
5351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5352 
 
5481 phani.kuma 5353 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5354 
    """
5355 
    Parameters:
5356 
     - vendorId
5481 phani.kuma 5357 
     - onlyVendorNotPaid
5358 
     - billingDateFrom
5359 
     - billingDateTo
4875 varun.gupt 5360 
    """
5481 phani.kuma 5361 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5362 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5363 
 
5481 phani.kuma 5364 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5365 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5366 
    args = getBilledOrders_args()
4875 varun.gupt 5367 
    args.vendorId = vendorId
5481 phani.kuma 5368 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5369 
    args.billingDateFrom = billingDateFrom
5370 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5371 
    args.write(self._oprot)
5372 
    self._oprot.writeMessageEnd()
5373 
    self._oprot.trans.flush()
5374 
 
5481 phani.kuma 5375 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5377 
    if mtype == TMessageType.EXCEPTION:
5378 
      x = TApplicationException()
5379 
      x.read(self._iprot)
5380 
      self._iprot.readMessageEnd()
5381 
      raise x
5481 phani.kuma 5382 
    result = getBilledOrders_result()
4875 varun.gupt 5383 
    result.read(self._iprot)
5384 
    self._iprot.readMessageEnd()
5385 
    if result.success is not None:
5386 
      return result.success
5387 
    if result.ex is not None:
5388 
      raise result.ex
5481 phani.kuma 5389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5390 
 
5031 varun.gupt 5391 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5392 
    """
5393 
    Parameters:
5394 
     - startDate
5395 
     - endDate
5396 
    """
5397 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5398 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5399 
 
5031 varun.gupt 5400 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5401 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5402 
    args = getStatusDistributionOfOrders_args()
5403 
    args.startDate = startDate
5404 
    args.endDate = endDate
5405 
    args.write(self._oprot)
5406 
    self._oprot.writeMessageEnd()
5407 
    self._oprot.trans.flush()
5408 
 
5409 
  def recv_getStatusDistributionOfOrders(self, ):
5410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5411 
    if mtype == TMessageType.EXCEPTION:
5412 
      x = TApplicationException()
5413 
      x.read(self._iprot)
5414 
      self._iprot.readMessageEnd()
5415 
      raise x
5416 
    result = getStatusDistributionOfOrders_result()
5417 
    result.read(self._iprot)
5418 
    self._iprot.readMessageEnd()
5419 
    if result.success is not None:
5420 
      return result.success
5421 
    if result.ex is not None:
5422 
      raise result.ex
5423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5424 
 
5067 varun.gupt 5425 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5426 
    """
5427 
    Parameters:
5428 
     - status
5429 
     - startDatetime
5430 
     - endDatetime
5431 
    """
5432 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5433 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5434 
 
5067 varun.gupt 5435 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5436 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5437 
    args = getOrderIdsForStatus_args()
5438 
    args.status = status
5439 
    args.startDatetime = startDatetime
5440 
    args.endDatetime = endDatetime
5441 
    args.write(self._oprot)
5442 
    self._oprot.writeMessageEnd()
5443 
    self._oprot.trans.flush()
5444 
 
5445 
  def recv_getOrderIdsForStatus(self, ):
5446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5447 
    if mtype == TMessageType.EXCEPTION:
5448 
      x = TApplicationException()
5449 
      x.read(self._iprot)
5450 
      self._iprot.readMessageEnd()
5451 
      raise x
5452 
    result = getOrderIdsForStatus_result()
5453 
    result.read(self._iprot)
5454 
    self._iprot.readMessageEnd()
5455 
    if result.success is not None:
5456 
      return result.success
5457 
    if result.ex is not None:
5458 
      raise result.ex
5459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5460 
 
5348 anupam.sin 5461 
  def updateCODAgent(self, agent, orderId):
5462 
    """
5463 
    Updates the agent who handled the COD verification call
5464 
 
5465 
    Parameters:
5466 
     - agent
5467 
     - orderId
5468 
    """
5469 
    self.send_updateCODAgent(agent, orderId)
5470 
    self.recv_updateCODAgent()
5471 
 
5472 
  def send_updateCODAgent(self, agent, orderId):
5473 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5474 
    args = updateCODAgent_args()
5475 
    args.agent = agent
5476 
    args.orderId = orderId
5477 
    args.write(self._oprot)
5478 
    self._oprot.writeMessageEnd()
5479 
    self._oprot.trans.flush()
5480 
 
5481 
  def recv_updateCODAgent(self, ):
5482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5483 
    if mtype == TMessageType.EXCEPTION:
5484 
      x = TApplicationException()
5485 
      x.read(self._iprot)
5486 
      self._iprot.readMessageEnd()
5487 
      raise x
5488 
    result = updateCODAgent_result()
5489 
    result.read(self._iprot)
5490 
    self._iprot.readMessageEnd()
5491 
    if result.ex is not None:
5492 
      raise result.ex
5493 
    return
5494 
 
5099 varun.gupt 5495 
  def updateOrderAsPaidToVendor(self, orderId):
5496 
    """
5497 
    Parameters:
5498 
     - orderId
5499 
    """
5500 
    self.send_updateOrderAsPaidToVendor(orderId)
5501 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5502 
 
5099 varun.gupt 5503 
  def send_updateOrderAsPaidToVendor(self, orderId):
5504 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5505 
    args = updateOrderAsPaidToVendor_args()
5506 
    args.orderId = orderId
5507 
    args.write(self._oprot)
5508 
    self._oprot.writeMessageEnd()
5509 
    self._oprot.trans.flush()
5510 
 
5511 
  def recv_updateOrderAsPaidToVendor(self, ):
5512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5513 
    if mtype == TMessageType.EXCEPTION:
5514 
      x = TApplicationException()
5515 
      x.read(self._iprot)
5516 
      self._iprot.readMessageEnd()
5517 
      raise x
5518 
    result = updateOrderAsPaidToVendor_result()
5519 
    result.read(self._iprot)
5520 
    self._iprot.readMessageEnd()
5521 
    if result.ex is not None:
5522 
      raise result.ex
5523 
    return
5524 
 
5386 phani.kuma 5525 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5526 
    """
5527 
    Parameters:
5528 
     - orderId
5529 
    """
5530 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5531 
    self.recv_updateOrderOnlyAsPaidToVendor()
5532 
 
5533 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5534 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5535 
    args = updateOrderOnlyAsPaidToVendor_args()
5536 
    args.orderId = orderId
5537 
    args.write(self._oprot)
5538 
    self._oprot.writeMessageEnd()
5539 
    self._oprot.trans.flush()
5540 
 
5541 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5543 
    if mtype == TMessageType.EXCEPTION:
5544 
      x = TApplicationException()
5545 
      x.read(self._iprot)
5546 
      self._iprot.readMessageEnd()
5547 
      raise x
5548 
    result = updateOrderOnlyAsPaidToVendor_result()
5549 
    result.read(self._iprot)
5550 
    self._iprot.readMessageEnd()
5551 
    if result.ex is not None:
5552 
      raise result.ex
5553 
    return
5554 
 
5208 varun.gupt 5555 
  def getRefundedOrdersMarkedPaid(self, ):
5556 
    self.send_getRefundedOrdersMarkedPaid()
5557 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5558 
 
5208 varun.gupt 5559 
  def send_getRefundedOrdersMarkedPaid(self, ):
5560 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5561 
    args = getRefundedOrdersMarkedPaid_args()
5562 
    args.write(self._oprot)
5563 
    self._oprot.writeMessageEnd()
5564 
    self._oprot.trans.flush()
5565 
 
5566 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5568 
    if mtype == TMessageType.EXCEPTION:
5569 
      x = TApplicationException()
5570 
      x.read(self._iprot)
5571 
      self._iprot.readMessageEnd()
5572 
      raise x
5573 
    result = getRefundedOrdersMarkedPaid_result()
5574 
    result.read(self._iprot)
5575 
    self._iprot.readMessageEnd()
5576 
    if result.success is not None:
5577 
      return result.success
5578 
    if result.ex is not None:
5579 
      raise result.ex
5580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5581 
 
5447 anupam.sin 5582 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5583 
    """
5584 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5585 
 
5447 anupam.sin 5586 
 
5587 
    Parameters:
5588 
     - minOrderId
5589 
     - maxOrderId
5590 
    """
5591 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5592 
    return self.recv_getAllVerificationAgents()
5593 
 
5594 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5595 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5596 
    args = getAllVerificationAgents_args()
5597 
    args.minOrderId = minOrderId
5598 
    args.maxOrderId = maxOrderId
5599 
    args.write(self._oprot)
5600 
    self._oprot.writeMessageEnd()
5601 
    self._oprot.trans.flush()
5602 
 
5603 
  def recv_getAllVerificationAgents(self, ):
5604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5605 
    if mtype == TMessageType.EXCEPTION:
5606 
      x = TApplicationException()
5607 
      x.read(self._iprot)
5608 
      self._iprot.readMessageEnd()
5609 
      raise x
5610 
    result = getAllVerificationAgents_result()
5611 
    result.read(self._iprot)
5612 
    self._iprot.readMessageEnd()
5613 
    if result.success is not None:
5614 
      return result.success
5615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5616 
 
5527 anupam.sin 5617 
  def getAllAttributesForOrderId(self, orderId):
5618 
    """
5619 
    gets all attributes for a given orderId
5447 anupam.sin 5620 
 
5527 anupam.sin 5621 
    Parameters:
5622 
     - orderId
5623 
    """
5624 
    self.send_getAllAttributesForOrderId(orderId)
5625 
    return self.recv_getAllAttributesForOrderId()
5626 
 
5627 
  def send_getAllAttributesForOrderId(self, orderId):
5628 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5629 
    args = getAllAttributesForOrderId_args()
5630 
    args.orderId = orderId
5631 
    args.write(self._oprot)
5632 
    self._oprot.writeMessageEnd()
5633 
    self._oprot.trans.flush()
5634 
 
5635 
  def recv_getAllAttributesForOrderId(self, ):
5636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5637 
    if mtype == TMessageType.EXCEPTION:
5638 
      x = TApplicationException()
5639 
      x.read(self._iprot)
5640 
      self._iprot.readMessageEnd()
5641 
      raise x
5642 
    result = getAllAttributesForOrderId_result()
5643 
    result.read(self._iprot)
5644 
    self._iprot.readMessageEnd()
5645 
    if result.success is not None:
5646 
      return result.success
5647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5648 
 
5676 rajveer 5649 
  def setOrderAttributes(self, orderId, attributes):
5650 
    """
5651 
    sets attributes for an order
5652 
 
5653 
    Parameters:
5654 
     - orderId
5655 
     - attributes
5656 
    """
5657 
    self.send_setOrderAttributes(orderId, attributes)
5658 
    self.recv_setOrderAttributes()
5659 
 
5660 
  def send_setOrderAttributes(self, orderId, attributes):
5661 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5662 
    args = setOrderAttributes_args()
5663 
    args.orderId = orderId
5664 
    args.attributes = attributes
5665 
    args.write(self._oprot)
5666 
    self._oprot.writeMessageEnd()
5667 
    self._oprot.trans.flush()
5668 
 
5669 
  def recv_setOrderAttributes(self, ):
5670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5671 
    if mtype == TMessageType.EXCEPTION:
5672 
      x = TApplicationException()
5673 
      x.read(self._iprot)
5674 
      self._iprot.readMessageEnd()
5675 
      raise x
5676 
    result = setOrderAttributes_result()
5677 
    result.read(self._iprot)
5678 
    self._iprot.readMessageEnd()
5679 
    return
5680 
 
5527 anupam.sin 5681 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5682 
    """
5683 
    sets attributes for all orders in a transaction
5684 
 
5685 
    Parameters:
5686 
     - transactionId
5687 
     - attribute
5688 
    """
5689 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5690 
    self.recv_setOrderAttributeForTransaction()
5691 
 
5692 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5693 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5694 
    args = setOrderAttributeForTransaction_args()
5695 
    args.transactionId = transactionId
5696 
    args.attribute = attribute
5697 
    args.write(self._oprot)
5698 
    self._oprot.writeMessageEnd()
5699 
    self._oprot.trans.flush()
5700 
 
5701 
  def recv_setOrderAttributeForTransaction(self, ):
5702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5703 
    if mtype == TMessageType.EXCEPTION:
5704 
      x = TApplicationException()
5705 
      x.read(self._iprot)
5706 
      self._iprot.readMessageEnd()
5707 
      raise x
5708 
    result = setOrderAttributeForTransaction_result()
5709 
    result.read(self._iprot)
5710 
    self._iprot.readMessageEnd()
5711 
    return
5712 
 
5553 rajveer 5713 
  def getReceivePendingOrders(self, storeId):
5714 
    """
5715 
    Parameters:
5716 
     - storeId
5717 
    """
5718 
    self.send_getReceivePendingOrders(storeId)
5719 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5720 
 
5553 rajveer 5721 
  def send_getReceivePendingOrders(self, storeId):
5722 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5723 
    args = getReceivePendingOrders_args()
5724 
    args.storeId = storeId
5725 
    args.write(self._oprot)
5726 
    self._oprot.writeMessageEnd()
5727 
    self._oprot.trans.flush()
5728 
 
5729 
  def recv_getReceivePendingOrders(self, ):
5730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5731 
    if mtype == TMessageType.EXCEPTION:
5732 
      x = TApplicationException()
5733 
      x.read(self._iprot)
5734 
      self._iprot.readMessageEnd()
5735 
      raise x
5736 
    result = getReceivePendingOrders_result()
5737 
    result.read(self._iprot)
5738 
    self._iprot.readMessageEnd()
5739 
    if result.success is not None:
5740 
      return result.success
5741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5742 
 
5743 
  def getReceivedAtStoreOrders(self, storeId):
5744 
    """
5745 
    Parameters:
5746 
     - storeId
5747 
    """
5748 
    self.send_getReceivedAtStoreOrders(storeId)
5749 
    return self.recv_getReceivedAtStoreOrders()
5750 
 
5751 
  def send_getReceivedAtStoreOrders(self, storeId):
5752 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5753 
    args = getReceivedAtStoreOrders_args()
5754 
    args.storeId = storeId
5755 
    args.write(self._oprot)
5756 
    self._oprot.writeMessageEnd()
5757 
    self._oprot.trans.flush()
5758 
 
5759 
  def recv_getReceivedAtStoreOrders(self, ):
5760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5761 
    if mtype == TMessageType.EXCEPTION:
5762 
      x = TApplicationException()
5763 
      x.read(self._iprot)
5764 
      self._iprot.readMessageEnd()
5765 
      raise x
5766 
    result = getReceivedAtStoreOrders_result()
5767 
    result.read(self._iprot)
5768 
    self._iprot.readMessageEnd()
5769 
    if result.success is not None:
5770 
      return result.success
5771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5772 
 
5713 rajveer 5773 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5774 
    """
5775 
    Parameters:
5776 
     - storeId
5777 
     - fromDate
5778 
     - toDate
5779 
     - onlyCod
5780 
    """
5781 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5782 
    return self.recv_getOrdersCollectionAtStore()
5783 
 
5784 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5785 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5786 
    args = getOrdersCollectionAtStore_args()
5787 
    args.storeId = storeId
5788 
    args.fromDate = fromDate
5789 
    args.toDate = toDate
5790 
    args.onlyCod = onlyCod
5791 
    args.write(self._oprot)
5792 
    self._oprot.writeMessageEnd()
5793 
    self._oprot.trans.flush()
5794 
 
5795 
  def recv_getOrdersCollectionAtStore(self, ):
5796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5797 
    if mtype == TMessageType.EXCEPTION:
5798 
      x = TApplicationException()
5799 
      x.read(self._iprot)
5800 
      self._iprot.readMessageEnd()
5801 
      raise x
5802 
    result = getOrdersCollectionAtStore_result()
5803 
    result.read(self._iprot)
5804 
    self._iprot.readMessageEnd()
5805 
    if result.success is not None:
5806 
      return result.success
5807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5808 
 
5833 rajveer 5809 
  def getOrderAttributeValue(self, orderId, attributeName):
5810 
    """
5811 
    Parameters:
5812 
     - orderId
5813 
     - attributeName
5814 
    """
5815 
    self.send_getOrderAttributeValue(orderId, attributeName)
5816 
    return self.recv_getOrderAttributeValue()
5817 
 
5818 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5819 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5820 
    args = getOrderAttributeValue_args()
5821 
    args.orderId = orderId
5822 
    args.attributeName = attributeName
5823 
    args.write(self._oprot)
5824 
    self._oprot.writeMessageEnd()
5825 
    self._oprot.trans.flush()
5826 
 
5827 
  def recv_getOrderAttributeValue(self, ):
5828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5829 
    if mtype == TMessageType.EXCEPTION:
5830 
      x = TApplicationException()
5831 
      x.read(self._iprot)
5832 
      self._iprot.readMessageEnd()
5833 
      raise x
5834 
    result = getOrderAttributeValue_result()
5835 
    result.read(self._iprot)
5836 
    self._iprot.readMessageEnd()
5837 
    if result.success is not None:
5838 
      return result.success
5839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5840 
 
6019 rajveer 5841 
  def changeJacketNumber(self, orderId, jacketNumber):
5842 
    """
5843 
    Parameters:
5844 
     - orderId
5845 
     - jacketNumber
5846 
    """
5847 
    self.send_changeJacketNumber(orderId, jacketNumber)
5848 
    return self.recv_changeJacketNumber()
5849 
 
5850 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5851 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5852 
    args = changeJacketNumber_args()
5853 
    args.orderId = orderId
5854 
    args.jacketNumber = jacketNumber
5855 
    args.write(self._oprot)
5856 
    self._oprot.writeMessageEnd()
5857 
    self._oprot.trans.flush()
5858 
 
5859 
  def recv_changeJacketNumber(self, ):
5860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5861 
    if mtype == TMessageType.EXCEPTION:
5862 
      x = TApplicationException()
5863 
      x.read(self._iprot)
5864 
      self._iprot.readMessageEnd()
5865 
      raise x
5866 
    result = changeJacketNumber_result()
5867 
    result.read(self._iprot)
5868 
    self._iprot.readMessageEnd()
5869 
    if result.success is not None:
5870 
      return result.success
5871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5872 
 
5873 
  def markOrderAsRtoInTransit(self, orderId):
5874 
    """
5875 
    Parameters:
5876 
     - orderId
5877 
    """
5878 
    self.send_markOrderAsRtoInTransit(orderId)
5879 
    return self.recv_markOrderAsRtoInTransit()
5880 
 
5881 
  def send_markOrderAsRtoInTransit(self, orderId):
5882 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5883 
    args = markOrderAsRtoInTransit_args()
5884 
    args.orderId = orderId
5885 
    args.write(self._oprot)
5886 
    self._oprot.writeMessageEnd()
5887 
    self._oprot.trans.flush()
5888 
 
5889 
  def recv_markOrderAsRtoInTransit(self, ):
5890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5891 
    if mtype == TMessageType.EXCEPTION:
5892 
      x = TApplicationException()
5893 
      x.read(self._iprot)
5894 
      self._iprot.readMessageEnd()
5895 
      raise x
5896 
    result = markOrderAsRtoInTransit_result()
5897 
    result.read(self._iprot)
5898 
    self._iprot.readMessageEnd()
5899 
    if result.success is not None:
5900 
      return result.success
5901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5902 
 
5593 mandeep.dh 5903 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5904 
    """
5905 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5906 
    invoked while scanning IN of items.
5553 rajveer 5907 
 
5593 mandeep.dh 5908 
    Parameters:
5909 
     - itemId
5910 
     - quantity
5911 
     - fulfilmentWarehouseId
5912 
     - billingWarehouseId
5913 
    """
5914 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5915 
    self.recv_acceptOrderForItem()
5916 
 
5917 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5918 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5919 
    args = acceptOrderForItem_args()
5920 
    args.itemId = itemId
5921 
    args.quantity = quantity
5922 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5923 
    args.billingWarehouseId = billingWarehouseId
5924 
    args.write(self._oprot)
5925 
    self._oprot.writeMessageEnd()
5926 
    self._oprot.trans.flush()
5927 
 
5928 
  def recv_acceptOrderForItem(self, ):
5929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5930 
    if mtype == TMessageType.EXCEPTION:
5931 
      x = TApplicationException()
5932 
      x.read(self._iprot)
5933 
      self._iprot.readMessageEnd()
5934 
      raise x
5935 
    result = acceptOrderForItem_result()
5936 
    result.read(self._iprot)
5937 
    self._iprot.readMessageEnd()
5938 
    return
5939 
 
6000 mandeep.dh 5940 
  def createRechargeOrder(self, rechargeOrder):
5941 
    """
5942 
    Parameters:
5943 
     - rechargeOrder
5944 
    """
5945 
    self.send_createRechargeOrder(rechargeOrder)
5946 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5947 
 
6000 mandeep.dh 5948 
  def send_createRechargeOrder(self, rechargeOrder):
5949 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5950 
    args = createRechargeOrder_args()
5951 
    args.rechargeOrder = rechargeOrder
5952 
    args.write(self._oprot)
5953 
    self._oprot.writeMessageEnd()
5954 
    self._oprot.trans.flush()
5955 
 
5956 
  def recv_createRechargeOrder(self, ):
5957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5958 
    if mtype == TMessageType.EXCEPTION:
5959 
      x = TApplicationException()
5960 
      x.read(self._iprot)
5961 
      self._iprot.readMessageEnd()
5962 
      raise x
5963 
    result = createRechargeOrder_result()
5964 
    result.read(self._iprot)
5965 
    self._iprot.readMessageEnd()
5966 
    if result.success is not None:
5967 
      return result.success
5968 
    if result.ex is not None:
5969 
      raise result.ex
5970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5971 
 
6031 rajveer 5972 
  def getRechargeOrder(self, rechargeRrderId):
5973 
    """
5974 
    Parameters:
5975 
     - rechargeRrderId
5976 
    """
5977 
    self.send_getRechargeOrder(rechargeRrderId)
5978 
    return self.recv_getRechargeOrder()
5979 
 
5980 
  def send_getRechargeOrder(self, rechargeRrderId):
5981 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5982 
    args = getRechargeOrder_args()
5983 
    args.rechargeRrderId = rechargeRrderId
5984 
    args.write(self._oprot)
5985 
    self._oprot.writeMessageEnd()
5986 
    self._oprot.trans.flush()
5987 
 
5988 
  def recv_getRechargeOrder(self, ):
5989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5990 
    if mtype == TMessageType.EXCEPTION:
5991 
      x = TApplicationException()
5992 
      x.read(self._iprot)
5993 
      self._iprot.readMessageEnd()
5994 
      raise x
5995 
    result = getRechargeOrder_result()
5996 
    result.read(self._iprot)
5997 
    self._iprot.readMessageEnd()
5998 
    if result.success is not None:
5999 
      return result.success
6000 
    if result.ex is not None:
6001 
      raise result.ex
6002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6003 
 
6004 
  def getRechargeOrders(self, userId):
6005 
    """
6006 
    Parameters:
6007 
     - userId
6008 
    """
6009 
    self.send_getRechargeOrders(userId)
6010 
    return self.recv_getRechargeOrders()
6011 
 
6012 
  def send_getRechargeOrders(self, userId):
6013 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6014 
    args = getRechargeOrders_args()
6015 
    args.userId = userId
6016 
    args.write(self._oprot)
6017 
    self._oprot.writeMessageEnd()
6018 
    self._oprot.trans.flush()
6019 
 
6020 
  def recv_getRechargeOrders(self, ):
6021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6022 
    if mtype == TMessageType.EXCEPTION:
6023 
      x = TApplicationException()
6024 
      x.read(self._iprot)
6025 
      self._iprot.readMessageEnd()
6026 
      raise x
6027 
    result = getRechargeOrders_result()
6028 
    result.read(self._iprot)
6029 
    self._iprot.readMessageEnd()
6030 
    if result.success is not None:
6031 
      return result.success
6032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6033 
 
6000 mandeep.dh 6034 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6035 
    """
6036 
    Parameters:
6037 
     - rechargeOrderId
6038 
     - rechargeOrderStatus
6039 
    """
6040 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6041 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6042 
 
6043 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6044 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6045 
    args = updateRechargeOrderStatus_args()
6046 
    args.rechargeOrderId = rechargeOrderId
6047 
    args.rechargeOrderStatus = rechargeOrderStatus
6048 
    args.write(self._oprot)
6049 
    self._oprot.writeMessageEnd()
6050 
    self._oprot.trans.flush()
6051 
 
6052 
  def recv_updateRechargeOrderStatus(self, ):
6053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6054 
    if mtype == TMessageType.EXCEPTION:
6055 
      x = TApplicationException()
6056 
      x.read(self._iprot)
6057 
      self._iprot.readMessageEnd()
6058 
      raise x
6059 
    result = updateRechargeOrderStatus_result()
6060 
    result.read(self._iprot)
6061 
    self._iprot.readMessageEnd()
6031 rajveer 6062 
    if result.success is not None:
6063 
      return result.success
6000 mandeep.dh 6064 
    if result.ex is not None:
6065 
      raise result.ex
6031 rajveer 6066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6067 
 
6031 rajveer 6068 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6069 
    """
6070 
    Parameters:
6031 rajveer 6071 
     - rechargeOrderId
6000 mandeep.dh 6072 
    """
6031 rajveer 6073 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6074 
    return self.recv_activateRechargeTxn()
6075 
 
6031 rajveer 6076 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6077 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6078 
    args = activateRechargeTxn_args()
6031 rajveer 6079 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6080 
    args.write(self._oprot)
6081 
    self._oprot.writeMessageEnd()
6082 
    self._oprot.trans.flush()
6083 
 
6084 
  def recv_activateRechargeTxn(self, ):
6085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6086 
    if mtype == TMessageType.EXCEPTION:
6087 
      x = TApplicationException()
6088 
      x.read(self._iprot)
6089 
      self._iprot.readMessageEnd()
6090 
      raise x
6091 
    result = activateRechargeTxn_result()
6092 
    result.read(self._iprot)
6093 
    self._iprot.readMessageEnd()
6094 
    if result.success is not None:
6095 
      return result.success
6096 
    if result.ex is not None:
6097 
      raise result.ex
6098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6099 
 
6031 rajveer 6100 
  def getUserWallet(self, userId):
6000 mandeep.dh 6101 
    """
6102 
    Parameters:
6031 rajveer 6103 
     - userId
6000 mandeep.dh 6104 
    """
6031 rajveer 6105 
    self.send_getUserWallet(userId)
6106 
    return self.recv_getUserWallet()
6000 mandeep.dh 6107 
 
6031 rajveer 6108 
  def send_getUserWallet(self, userId):
6109 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6110 
    args = getUserWallet_args()
6111 
    args.userId = userId
6000 mandeep.dh 6112 
    args.write(self._oprot)
6113 
    self._oprot.writeMessageEnd()
6114 
    self._oprot.trans.flush()
6115 
 
6031 rajveer 6116 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6118 
    if mtype == TMessageType.EXCEPTION:
6119 
      x = TApplicationException()
6120 
      x.read(self._iprot)
6121 
      self._iprot.readMessageEnd()
6122 
      raise x
6031 rajveer 6123 
    result = getUserWallet_result()
6000 mandeep.dh 6124 
    result.read(self._iprot)
6125 
    self._iprot.readMessageEnd()
6126 
    if result.success is not None:
6127 
      return result.success
6031 rajveer 6128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6129 
 
6031 rajveer 6130 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6131 
    """
6132 
    Parameters:
6031 rajveer 6133 
     - userId
6000 mandeep.dh 6134 
    """
6031 rajveer 6135 
    self.send_getUserWalletHistory(userId)
6136 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6137 
 
6031 rajveer 6138 
  def send_getUserWalletHistory(self, userId):
6139 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6140 
    args = getUserWalletHistory_args()
6141 
    args.userId = userId
6000 mandeep.dh 6142 
    args.write(self._oprot)
6143 
    self._oprot.writeMessageEnd()
6144 
    self._oprot.trans.flush()
6145 
 
6031 rajveer 6146 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6148 
    if mtype == TMessageType.EXCEPTION:
6149 
      x = TApplicationException()
6150 
      x.read(self._iprot)
6151 
      self._iprot.readMessageEnd()
6152 
      raise x
6031 rajveer 6153 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6154 
    result.read(self._iprot)
6155 
    self._iprot.readMessageEnd()
6156 
    if result.success is not None:
6157 
      return result.success
6031 rajveer 6158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6159 
 
6050 anupam.sin 6160 
  def getRechargeOrdersForTransaction(self, txnId):
6161 
    """
6162 
    Returns a recharge order for a given transactionId
6163 
 
6164 
    Parameters:
6165 
     - txnId
6166 
    """
6167 
    self.send_getRechargeOrdersForTransaction(txnId)
6168 
    return self.recv_getRechargeOrdersForTransaction()
6169 
 
6170 
  def send_getRechargeOrdersForTransaction(self, txnId):
6171 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6172 
    args = getRechargeOrdersForTransaction_args()
6173 
    args.txnId = txnId
6174 
    args.write(self._oprot)
6175 
    self._oprot.writeMessageEnd()
6176 
    self._oprot.trans.flush()
6177 
 
6178 
  def recv_getRechargeOrdersForTransaction(self, ):
6179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6180 
    if mtype == TMessageType.EXCEPTION:
6181 
      x = TApplicationException()
6182 
      x.read(self._iprot)
6183 
      self._iprot.readMessageEnd()
6184 
      raise x
6185 
    result = getRechargeOrdersForTransaction_result()
6186 
    result.read(self._iprot)
6187 
    self._iprot.readMessageEnd()
6188 
    if result.success is not None:
6189 
      return result.success
6190 
    if result.ex is not None:
6191 
      raise result.ex
6192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6193 
 
6206 rajveer 6194 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6195 
    """
6196 
    Parameters:
6197 
     - rechargeType
6206 rajveer 6198 
     - onlyActive
6048 rajveer 6199 
    """
6206 rajveer 6200 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6201 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6202 
 
6206 rajveer 6203 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6204 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6205 
    args = getServiceProviders_args()
6206 
    args.rechargeType = rechargeType
6206 rajveer 6207 
    args.onlyActive = onlyActive
6048 rajveer 6208 
    args.write(self._oprot)
6209 
    self._oprot.writeMessageEnd()
6210 
    self._oprot.trans.flush()
6211 
 
6212 
  def recv_getServiceProviders(self, ):
6213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6214 
    if mtype == TMessageType.EXCEPTION:
6215 
      x = TApplicationException()
6216 
      x.read(self._iprot)
6217 
      self._iprot.readMessageEnd()
6218 
      raise x
6219 
    result = getServiceProviders_result()
6220 
    result.read(self._iprot)
6221 
    self._iprot.readMessageEnd()
6222 
    if result.success is not None:
6223 
      return result.success
6224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6225 
 
6049 rajveer 6226 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6227 
    """
6228 
    Parameters:
6049 rajveer 6229 
     - rechargeType
6048 rajveer 6230 
     - deviceNumber
6231 
    """
6049 rajveer 6232 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6233 
    return self.recv_getServiceProviderForDevice()
6234 
 
6049 rajveer 6235 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6236 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6237 
    args = getServiceProviderForDevice_args()
6049 rajveer 6238 
    args.rechargeType = rechargeType
6048 rajveer 6239 
    args.deviceNumber = deviceNumber
6240 
    args.write(self._oprot)
6241 
    self._oprot.writeMessageEnd()
6242 
    self._oprot.trans.flush()
6243 
 
6244 
  def recv_getServiceProviderForDevice(self, ):
6245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6246 
    if mtype == TMessageType.EXCEPTION:
6247 
      x = TApplicationException()
6248 
      x.read(self._iprot)
6249 
      self._iprot.readMessageEnd()
6250 
      raise x
6251 
    result = getServiceProviderForDevice_result()
6252 
    result.read(self._iprot)
6253 
    self._iprot.readMessageEnd()
6254 
    if result.success is not None:
6255 
      return result.success
6256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6257 
 
6591 anupam.sin 6258 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6259 
    """
6260 
    Parameters:
6261 
     - rechargeType
6262 
     - deviceNumber
6307 anupam.sin 6263 
     - userSelectedProviderId
6591 anupam.sin 6264 
     - clientAddress
6269 rajveer 6265 
    """
6591 anupam.sin 6266 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6267 
    return self.recv_validateRecharge()
6268 
 
6591 anupam.sin 6269 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6270 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6271 
    args = validateRecharge_args()
6272 
    args.rechargeType = rechargeType
6273 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6274 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6275 
    args.clientAddress = clientAddress
6269 rajveer 6276 
    args.write(self._oprot)
6277 
    self._oprot.writeMessageEnd()
6278 
    self._oprot.trans.flush()
6279 
 
6280 
  def recv_validateRecharge(self, ):
6281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6282 
    if mtype == TMessageType.EXCEPTION:
6283 
      x = TApplicationException()
6284 
      x.read(self._iprot)
6285 
      self._iprot.readMessageEnd()
6286 
      raise x
6287 
    result = validateRecharge_result()
6288 
    result.read(self._iprot)
6289 
    self._iprot.readMessageEnd()
6290 
    if result.success is not None:
6291 
      return result.success
6292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6293 
 
6094 rajveer 6294 
  def getRechargeOrdersForDevice(self, deviceNumber):
6295 
    """
6296 
    Parameters:
6297 
     - deviceNumber
6298 
    """
6299 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6300 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6301 
 
6094 rajveer 6302 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6303 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6304 
    args = getRechargeOrdersForDevice_args()
6305 
    args.deviceNumber = deviceNumber
6306 
    args.write(self._oprot)
6307 
    self._oprot.writeMessageEnd()
6308 
    self._oprot.trans.flush()
6309 
 
6310 
  def recv_getRechargeOrdersForDevice(self, ):
6311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6312 
    if mtype == TMessageType.EXCEPTION:
6313 
      x = TApplicationException()
6314 
      x.read(self._iprot)
6315 
      self._iprot.readMessageEnd()
6316 
      raise x
6317 
    result = getRechargeOrdersForDevice_result()
6318 
    result.read(self._iprot)
6319 
    self._iprot.readMessageEnd()
6320 
    if result.success is not None:
6321 
      return result.success
6322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6323 
 
6324 
  def addAmountToWallet(self, userId, orderId, amount):
6325 
    """
6326 
    Parameters:
6327 
     - userId
6328 
     - orderId
6329 
     - amount
6330 
    """
6331 
    self.send_addAmountToWallet(userId, orderId, amount)
6332 
    self.recv_addAmountToWallet()
6333 
 
6334 
  def send_addAmountToWallet(self, userId, orderId, amount):
6335 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6336 
    args = addAmountToWallet_args()
6337 
    args.userId = userId
6338 
    args.orderId = orderId
6339 
    args.amount = amount
6340 
    args.write(self._oprot)
6341 
    self._oprot.writeMessageEnd()
6342 
    self._oprot.trans.flush()
6343 
 
6344 
  def recv_addAmountToWallet(self, ):
6345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6346 
    if mtype == TMessageType.EXCEPTION:
6347 
      x = TApplicationException()
6348 
      x.read(self._iprot)
6349 
      self._iprot.readMessageEnd()
6350 
      raise x
6351 
    result = addAmountToWallet_result()
6352 
    result.read(self._iprot)
6353 
    self._iprot.readMessageEnd()
6354 
    return
6355 
 
6188 rajveer 6356 
  def getRechargeStatistics(self, ):
6357 
    self.send_getRechargeStatistics()
6358 
    return self.recv_getRechargeStatistics()
6359 
 
6360 
  def send_getRechargeStatistics(self, ):
6361 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6362 
    args = getRechargeStatistics_args()
6363 
    args.write(self._oprot)
6364 
    self._oprot.writeMessageEnd()
6365 
    self._oprot.trans.flush()
6366 
 
6367 
  def recv_getRechargeStatistics(self, ):
6368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6369 
    if mtype == TMessageType.EXCEPTION:
6370 
      x = TApplicationException()
6371 
      x.read(self._iprot)
6372 
      self._iprot.readMessageEnd()
6373 
      raise x
6374 
    result = getRechargeStatistics_result()
6375 
    result.read(self._iprot)
6376 
    self._iprot.readMessageEnd()
6377 
    if result.success is not None:
6378 
      return result.success
6379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6380 
 
6154 rajveer 6381 
  def getRechargeOrdersForStatus(self, status):
6382 
    """
6383 
    Parameters:
6384 
     - status
6385 
    """
6386 
    self.send_getRechargeOrdersForStatus(status)
6387 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6388 
 
6154 rajveer 6389 
  def send_getRechargeOrdersForStatus(self, status):
6390 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6391 
    args = getRechargeOrdersForStatus_args()
6392 
    args.status = status
6393 
    args.write(self._oprot)
6394 
    self._oprot.writeMessageEnd()
6395 
    self._oprot.trans.flush()
6396 
 
6397 
  def recv_getRechargeOrdersForStatus(self, ):
6398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6399 
    if mtype == TMessageType.EXCEPTION:
6400 
      x = TApplicationException()
6401 
      x.read(self._iprot)
6402 
      self._iprot.readMessageEnd()
6403 
      raise x
6404 
    result = getRechargeOrdersForStatus_result()
6405 
    result.read(self._iprot)
6406 
    self._iprot.readMessageEnd()
6407 
    if result.success is not None:
6408 
      return result.success
6409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6410 
 
6159 rajveer 6411 
  def getPlansForOperator(self, operatorId):
6412 
    """
6413 
    Parameters:
6414 
     - operatorId
6415 
    """
6416 
    self.send_getPlansForOperator(operatorId)
6417 
    return self.recv_getPlansForOperator()
6154 rajveer 6418 
 
6159 rajveer 6419 
  def send_getPlansForOperator(self, operatorId):
6420 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6421 
    args = getPlansForOperator_args()
6422 
    args.operatorId = operatorId
6423 
    args.write(self._oprot)
6424 
    self._oprot.writeMessageEnd()
6425 
    self._oprot.trans.flush()
6426 
 
6427 
  def recv_getPlansForOperator(self, ):
6428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6429 
    if mtype == TMessageType.EXCEPTION:
6430 
      x = TApplicationException()
6431 
      x.read(self._iprot)
6432 
      self._iprot.readMessageEnd()
6433 
      raise x
6434 
    result = getPlansForOperator_result()
6435 
    result.read(self._iprot)
6436 
    self._iprot.readMessageEnd()
6437 
    if result.success is not None:
6438 
      return result.success
6439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6440 
 
6307 anupam.sin 6441 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6442 
    """
6443 
    Returns denominations for a given operator and circle
6159 rajveer 6444 
 
6289 anupam.sin 6445 
    Parameters:
6446 
     - operatorId
6307 anupam.sin 6447 
     - circleCode
6289 anupam.sin 6448 
     - denominationType
6449 
    """
6307 anupam.sin 6450 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6451 
    return self.recv_getRechargeDenominations()
6452 
 
6307 anupam.sin 6453 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6454 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6455 
    args = getRechargeDenominations_args()
6456 
    args.operatorId = operatorId
6307 anupam.sin 6457 
    args.circleCode = circleCode
6289 anupam.sin 6458 
    args.denominationType = denominationType
6459 
    args.write(self._oprot)
6460 
    self._oprot.writeMessageEnd()
6461 
    self._oprot.trans.flush()
6462 
 
6463 
  def recv_getRechargeDenominations(self, ):
6464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6465 
    if mtype == TMessageType.EXCEPTION:
6466 
      x = TApplicationException()
6467 
      x.read(self._iprot)
6468 
      self._iprot.readMessageEnd()
6469 
      raise x
6470 
    result = getRechargeDenominations_result()
6471 
    result.read(self._iprot)
6472 
    self._iprot.readMessageEnd()
6473 
    if result.success is not None:
6474 
      return result.success
6475 
    if result.ex is not None:
6476 
      raise result.ex
6477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6478 
 
6371 rajveer 6479 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6480 
    """
6481 
    Parameters:
6482 
     - operatorId
6483 
     - circleId
6484 
     - isAvailable
6485 
    """
6486 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6487 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6488 
 
6371 rajveer 6489 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6490 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6491 
    args = updateAvailabilityStatus_args()
6492 
    args.operatorId = operatorId
6493 
    args.circleId = circleId
6494 
    args.isAvailable = isAvailable
6495 
    args.write(self._oprot)
6496 
    self._oprot.writeMessageEnd()
6497 
    self._oprot.trans.flush()
6498 
 
6499 
  def recv_updateAvailabilityStatus(self, ):
6500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6501 
    if mtype == TMessageType.EXCEPTION:
6502 
      x = TApplicationException()
6503 
      x.read(self._iprot)
6504 
      self._iprot.readMessageEnd()
6505 
      raise x
6506 
    result = updateAvailabilityStatus_result()
6507 
    result.read(self._iprot)
6508 
    self._iprot.readMessageEnd()
6509 
    return
6510 
 
6389 rajveer 6511 
  def getAvailableEmiSchemes(self, ):
6512 
    self.send_getAvailableEmiSchemes()
6513 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6514 
 
6389 rajveer 6515 
  def send_getAvailableEmiSchemes(self, ):
6516 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6517 
    args = getAvailableEmiSchemes_args()
6518 
    args.write(self._oprot)
6519 
    self._oprot.writeMessageEnd()
6520 
    self._oprot.trans.flush()
6521 
 
6522 
  def recv_getAvailableEmiSchemes(self, ):
6523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6524 
    if mtype == TMessageType.EXCEPTION:
6525 
      x = TApplicationException()
6526 
      x.read(self._iprot)
6527 
      self._iprot.readMessageEnd()
6528 
      raise x
6529 
    result = getAvailableEmiSchemes_result()
6530 
    result.read(self._iprot)
6531 
    self._iprot.readMessageEnd()
6532 
    if result.success is not None:
6533 
      return result.success
6534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6535 
 
6536 
  def getMiscCharges(self, transactionId):
6537 
    """
6538 
    Parameters:
6539 
     - transactionId
6540 
    """
6541 
    self.send_getMiscCharges(transactionId)
6542 
    return self.recv_getMiscCharges()
6543 
 
6544 
  def send_getMiscCharges(self, transactionId):
6545 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6546 
    args = getMiscCharges_args()
6547 
    args.transactionId = transactionId
6548 
    args.write(self._oprot)
6549 
    self._oprot.writeMessageEnd()
6550 
    self._oprot.trans.flush()
6551 
 
6552 
  def recv_getMiscCharges(self, ):
6553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6554 
    if mtype == TMessageType.EXCEPTION:
6555 
      x = TApplicationException()
6556 
      x.read(self._iprot)
6557 
      self._iprot.readMessageEnd()
6558 
      raise x
6559 
    result = getMiscCharges_result()
6560 
    result.read(self._iprot)
6561 
    self._iprot.readMessageEnd()
6562 
    if result.success is not None:
6563 
      return result.success
6564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6565 
 
6507 anupam.sin 6566 
  def refundRechargeOrder(self, rechargeOrderId):
6567 
    """
6568 
    Parameters:
6569 
     - rechargeOrderId
6570 
    """
6571 
    self.send_refundRechargeOrder(rechargeOrderId)
6572 
    return self.recv_refundRechargeOrder()
6389 rajveer 6573 
 
6507 anupam.sin 6574 
  def send_refundRechargeOrder(self, rechargeOrderId):
6575 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6576 
    args = refundRechargeOrder_args()
6577 
    args.rechargeOrderId = rechargeOrderId
6578 
    args.write(self._oprot)
6579 
    self._oprot.writeMessageEnd()
6580 
    self._oprot.trans.flush()
6581 
 
6582 
  def recv_refundRechargeOrder(self, ):
6583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6584 
    if mtype == TMessageType.EXCEPTION:
6585 
      x = TApplicationException()
6586 
      x.read(self._iprot)
6587 
      self._iprot.readMessageEnd()
6588 
      raise x
6589 
    result = refundRechargeOrder_result()
6590 
    result.read(self._iprot)
6591 
    self._iprot.readMessageEnd()
6592 
    if result.success is not None:
6593 
      return result.success
6594 
    if result.ex is not None:
6595 
      raise result.ex
6596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6597 
 
6821 amar.kumar 6598 
  def getPhysicalOrders(self, fromDate, toDate):
6599 
    """
6600 
    Parameters:
6601 
     - fromDate
6602 
     - toDate
6603 
    """
6604 
    self.send_getPhysicalOrders(fromDate, toDate)
6605 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6606 
 
6821 amar.kumar 6607 
  def send_getPhysicalOrders(self, fromDate, toDate):
6608 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6609 
    args = getPhysicalOrders_args()
6610 
    args.fromDate = fromDate
6611 
    args.toDate = toDate
6612 
    args.write(self._oprot)
6613 
    self._oprot.writeMessageEnd()
6614 
    self._oprot.trans.flush()
6615 
 
6616 
  def recv_getPhysicalOrders(self, ):
6617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6618 
    if mtype == TMessageType.EXCEPTION:
6619 
      x = TApplicationException()
6620 
      x.read(self._iprot)
6621 
      self._iprot.readMessageEnd()
6622 
      raise x
6623 
    result = getPhysicalOrders_result()
6624 
    result.read(self._iprot)
6625 
    self._iprot.readMessageEnd()
6626 
    if result.success is not None:
6627 
      return result.success
6628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6629 
 
6906 rajveer 6630 
  def getDocument(self, docType, docSource):
6631 
    """
6632 
    Parameters:
6633 
     - docType
6634 
     - docSource
6635 
    """
6636 
    self.send_getDocument(docType, docSource)
6637 
    return self.recv_getDocument()
6821 amar.kumar 6638 
 
6906 rajveer 6639 
  def send_getDocument(self, docType, docSource):
6640 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6641 
    args = getDocument_args()
6642 
    args.docType = docType
6643 
    args.docSource = docSource
6644 
    args.write(self._oprot)
6645 
    self._oprot.writeMessageEnd()
6646 
    self._oprot.trans.flush()
6647 
 
6648 
  def recv_getDocument(self, ):
6649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6650 
    if mtype == TMessageType.EXCEPTION:
6651 
      x = TApplicationException()
6652 
      x.read(self._iprot)
6653 
      self._iprot.readMessageEnd()
6654 
      raise x
6655 
    result = getDocument_result()
6656 
    result.read(self._iprot)
6657 
    self._iprot.readMessageEnd()
6658 
    if result.success is not None:
6659 
      return result.success
6660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6661 
 
6985 anupam.sin 6662 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6663 
    """
6664 
    Parameters:
6665 
     - orderId
6666 
     - line1
6667 
     - line2
6668 
     - city
6669 
     - state
6670 
     - pin
6671 
    """
6672 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6673 
    return self.recv_changeShippingAddress()
6906 rajveer 6674 
 
6985 anupam.sin 6675 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6676 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6677 
    args = changeShippingAddress_args()
6678 
    args.orderId = orderId
6679 
    args.line1 = line1
6680 
    args.line2 = line2
6681 
    args.city = city
6682 
    args.state = state
6683 
    args.pin = pin
6684 
    args.write(self._oprot)
6685 
    self._oprot.writeMessageEnd()
6686 
    self._oprot.trans.flush()
6687 
 
6688 
  def recv_changeShippingAddress(self, ):
6689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6690 
    if mtype == TMessageType.EXCEPTION:
6691 
      x = TApplicationException()
6692 
      x.read(self._iprot)
6693 
      self._iprot.readMessageEnd()
6694 
      raise x
6695 
    result = changeShippingAddress_result()
6696 
    result.read(self._iprot)
6697 
    self._iprot.readMessageEnd()
6698 
    if result.success is not None:
6699 
      return result.success
6700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6701 
 
6988 rajveer 6702 
  def retrieveInvoice(self, orderId):
6703 
    """
6704 
    Parameters:
6705 
     - orderId
6706 
    """
6707 
    self.send_retrieveInvoice(orderId)
6708 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6709 
 
6988 rajveer 6710 
  def send_retrieveInvoice(self, orderId):
6711 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6712 
    args = retrieveInvoice_args()
6713 
    args.orderId = orderId
6714 
    args.write(self._oprot)
6715 
    self._oprot.writeMessageEnd()
6716 
    self._oprot.trans.flush()
6717 
 
6718 
  def recv_retrieveInvoice(self, ):
6719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6720 
    if mtype == TMessageType.EXCEPTION:
6721 
      x = TApplicationException()
6722 
      x.read(self._iprot)
6723 
      self._iprot.readMessageEnd()
6724 
      raise x
6725 
    result = retrieveInvoice_result()
6726 
    result.read(self._iprot)
6727 
    self._iprot.readMessageEnd()
6728 
    if result.success is not None:
6729 
      return result.success
6730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6731 
 
7026 rajveer 6732 
  def receiveUpdatesForRedExpress(self, awbNumber):
6733 
    """
6734 
    Parameters:
6735 
     - awbNumber
6736 
    """
6737 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6738 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6739 
 
7026 rajveer 6740 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6741 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6742 
    args = receiveUpdatesForRedExpress_args()
6743 
    args.awbNumber = awbNumber
6744 
    args.write(self._oprot)
6745 
    self._oprot.writeMessageEnd()
6746 
    self._oprot.trans.flush()
6747 
 
6748 
  def recv_receiveUpdatesForRedExpress(self, ):
6749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6750 
    if mtype == TMessageType.EXCEPTION:
6751 
      x = TApplicationException()
6752 
      x.read(self._iprot)
6753 
      self._iprot.readMessageEnd()
6754 
      raise x
6755 
    result = receiveUpdatesForRedExpress_result()
6756 
    result.read(self._iprot)
6757 
    self._iprot.readMessageEnd()
6758 
    if result.success is not None:
6759 
      return result.success
6760 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6761 
 
7073 anupam.sin 6762 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6763 
    """
6764 
    Parameters:
6765 
     - thriftRechargeTransaction
6766 
    """
6767 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6768 
    return self.recv_createRechargeTransaction()
7026 rajveer 6769 
 
7073 anupam.sin 6770 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6771 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6772 
    args = createRechargeTransaction_args()
6773 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6774 
    args.write(self._oprot)
6775 
    self._oprot.writeMessageEnd()
6776 
    self._oprot.trans.flush()
6777 
 
6778 
  def recv_createRechargeTransaction(self, ):
6779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6780 
    if mtype == TMessageType.EXCEPTION:
6781 
      x = TApplicationException()
6782 
      x.read(self._iprot)
6783 
      self._iprot.readMessageEnd()
6784 
      raise x
6785 
    result = createRechargeTransaction_result()
6786 
    result.read(self._iprot)
6787 
    self._iprot.readMessageEnd()
6788 
    if result.success is not None:
6789 
      return result.success
6790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6791 
 
6792 
 
3376 rajveer 6793 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6794 
  def __init__(self, handler):
3376 rajveer 6795 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6796 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6797 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6798 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6799 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6800 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6801 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6802 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6803 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6804 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6805 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6806 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6807 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6808 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6809 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6810 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6811 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6812 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6813 
    self._processMap["createOrder"] = Processor.process_createOrder
6814 
    self._processMap["getOrder"] = Processor.process_getOrder
6815 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6816 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6817 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6818 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6819 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6820 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6821 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6822 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6823 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6824 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6825 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6826 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6827 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6828 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6829 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6830 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6831 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6832 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6833 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6834 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6835 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6836 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6837 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6838 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6839 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6840 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6841 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6842 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6843 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6844 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6845 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6846 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6847 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6848 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6849 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6850 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6851 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6852 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6853 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6854 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6855 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6856 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6857 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6858 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6859 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6860 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6861 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6862 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6863 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6864 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6865 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6866 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6867 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6868 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6869 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6870 
    self._processMap["changeItem"] = Processor.process_changeItem
6871 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6872 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6873 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6874 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6875 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6876 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6877 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6878 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6879 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6880 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6881 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6882 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6883 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6884 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6885 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6886 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6887 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6888 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6889 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6890 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6891 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6892 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6893 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6894 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6895 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6896 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6897 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6898 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6899 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6900 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6901 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6902 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6903 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6904 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6905 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6906 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6907 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6908 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6909 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6910 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6911 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6912 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6913 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6914 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6915 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6916 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6917 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6918 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6919 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6920 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6921 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6922 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6923 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6924 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6925 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6926 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6927 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6928 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6929 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6930 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6931 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6932 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6933 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6934 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6935 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6936 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6937 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6938 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6939 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6940 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6941 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6942 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 6943 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 6944 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 6945 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 6946 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 6947 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 6948 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 6949 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
94 ashish 6950 
 
6951 
  def process(self, iprot, oprot):
6952 
    (name, type, seqid) = iprot.readMessageBegin()
6953 
    if name not in self._processMap:
6954 
      iprot.skip(TType.STRUCT)
6955 
      iprot.readMessageEnd()
6956 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6957 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6958 
      x.write(oprot)
6959 
      oprot.writeMessageEnd()
6960 
      oprot.trans.flush()
6961 
      return
6962 
    else:
6963 
      self._processMap[name](self, seqid, iprot, oprot)
6964 
    return True
6965 
 
6966 
  def process_createTransaction(self, seqid, iprot, oprot):
6967 
    args = createTransaction_args()
6968 
    args.read(iprot)
6969 
    iprot.readMessageEnd()
6970 
    result = createTransaction_result()
6971 
    try:
132 ashish 6972 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6973 
    except TransactionServiceException, ex:
6974 
      result.ex = ex
6975 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6976 
    result.write(oprot)
6977 
    oprot.writeMessageEnd()
6978 
    oprot.trans.flush()
6979 
 
6980 
  def process_getTransaction(self, seqid, iprot, oprot):
6981 
    args = getTransaction_args()
6982 
    args.read(iprot)
6983 
    iprot.readMessageEnd()
6984 
    result = getTransaction_result()
6985 
    try:
6986 
      result.success = self._handler.getTransaction(args.id)
6987 
    except TransactionServiceException, ex:
6988 
      result.ex = ex
6989 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6990 
    result.write(oprot)
6991 
    oprot.writeMessageEnd()
6992 
    oprot.trans.flush()
6993 
 
6994 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6995 
    args = getTransactionsForCustomer_args()
6996 
    args.read(iprot)
6997 
    iprot.readMessageEnd()
6998 
    result = getTransactionsForCustomer_result()
6999 
    try:
7000 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7001 
    except TransactionServiceException, ex:
7002 
      result.ex = ex
7003 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7004 
    result.write(oprot)
7005 
    oprot.writeMessageEnd()
7006 
    oprot.trans.flush()
7007 
 
132 ashish 7008 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7009 
    args = getTransactionsForShoppingCartId_args()
7010 
    args.read(iprot)
7011 
    iprot.readMessageEnd()
7012 
    result = getTransactionsForShoppingCartId_result()
7013 
    try:
7014 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7015 
    except TransactionServiceException, ex:
7016 
      result.ex = ex
7017 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7018 
    result.write(oprot)
7019 
    oprot.writeMessageEnd()
7020 
    oprot.trans.flush()
7021 
 
94 ashish 7022 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7023 
    args = getTransactionStatus_args()
7024 
    args.read(iprot)
7025 
    iprot.readMessageEnd()
7026 
    result = getTransactionStatus_result()
7027 
    try:
7028 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7029 
    except TransactionServiceException, ex:
7030 
      result.ex = ex
7031 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7032 
    result.write(oprot)
7033 
    oprot.writeMessageEnd()
7034 
    oprot.trans.flush()
7035 
 
7036 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7037 
    args = changeTransactionStatus_args()
7038 
    args.read(iprot)
7039 
    iprot.readMessageEnd()
7040 
    result = changeTransactionStatus_result()
7041 
    try:
5527 anupam.sin 7042 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7043 
    except TransactionServiceException, ex:
7044 
      result.ex = ex
7045 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7046 
    result.write(oprot)
7047 
    oprot.writeMessageEnd()
7048 
    oprot.trans.flush()
7049 
 
1398 varun.gupt 7050 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7051 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7052 
    args.read(iprot)
7053 
    iprot.readMessageEnd()
1398 varun.gupt 7054 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7055 
    try:
1398 varun.gupt 7056 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7057 
    except TransactionServiceException, ex:
7058 
      result.ex = ex
1398 varun.gupt 7059 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7060 
    result.write(oprot)
7061 
    oprot.writeMessageEnd()
7062 
    oprot.trans.flush()
7063 
 
483 rajveer 7064 
  def process_getAllOrders(self, seqid, iprot, oprot):
7065 
    args = getAllOrders_args()
94 ashish 7066 
    args.read(iprot)
7067 
    iprot.readMessageEnd()
483 rajveer 7068 
    result = getAllOrders_result()
94 ashish 7069 
    try:
4801 anupam.sin 7070 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7071 
    except TransactionServiceException, ex:
7072 
      result.ex = ex
483 rajveer 7073 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7074 
    result.write(oprot)
7075 
    oprot.writeMessageEnd()
7076 
    oprot.trans.flush()
7077 
 
4133 chandransh 7078 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7079 
    args = getOrdersInBatch_args()
7080 
    args.read(iprot)
7081 
    iprot.readMessageEnd()
7082 
    result = getOrdersInBatch_result()
7083 
    try:
7084 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7085 
    except TransactionServiceException, ex:
7086 
      result.ex = ex
7087 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7088 
    result.write(oprot)
7089 
    oprot.writeMessageEnd()
7090 
    oprot.trans.flush()
7091 
 
7092 
  def process_getOrderCount(self, seqid, iprot, oprot):
7093 
    args = getOrderCount_args()
7094 
    args.read(iprot)
7095 
    iprot.readMessageEnd()
7096 
    result = getOrderCount_result()
7097 
    try:
7098 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7099 
    except TransactionServiceException, ex:
7100 
      result.ex = ex
7101 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7102 
    result.write(oprot)
7103 
    oprot.writeMessageEnd()
7104 
    oprot.trans.flush()
7105 
 
999 varun.gupt 7106 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7107 
    args = getOrdersByBillingDate_args()
7108 
    args.read(iprot)
7109 
    iprot.readMessageEnd()
7110 
    result = getOrdersByBillingDate_result()
7111 
    try:
7112 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7113 
    except TransactionServiceException, ex:
7114 
      result.ex = ex
7115 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7116 
    result.write(oprot)
7117 
    oprot.writeMessageEnd()
7118 
    oprot.trans.flush()
7119 
 
3427 chandransh 7120 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7121 
    args = getOrdersByShippingDate_args()
7122 
    args.read(iprot)
7123 
    iprot.readMessageEnd()
7124 
    result = getOrdersByShippingDate_result()
7125 
    try:
3451 chandransh 7126 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7127 
    except TransactionServiceException, ex:
7128 
      result.ex = ex
7129 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7130 
    result.write(oprot)
7131 
    oprot.writeMessageEnd()
7132 
    oprot.trans.flush()
7133 
 
1382 varun.gupt 7134 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7135 
    args = getReturnableOrdersForCustomer_args()
7136 
    args.read(iprot)
7137 
    iprot.readMessageEnd()
7138 
    result = getReturnableOrdersForCustomer_result()
7139 
    try:
7140 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7141 
    except TransactionServiceException, ex:
7142 
      result.ex = ex
7143 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7144 
    result.write(oprot)
7145 
    oprot.writeMessageEnd()
7146 
    oprot.trans.flush()
7147 
 
7148 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7149 
    args = getCancellableOrdersForCustomer_args()
7150 
    args.read(iprot)
7151 
    iprot.readMessageEnd()
7152 
    result = getCancellableOrdersForCustomer_result()
7153 
    try:
7154 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7155 
    except TransactionServiceException, ex:
7156 
      result.ex = ex
7157 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7158 
    result.write(oprot)
7159 
    oprot.writeMessageEnd()
7160 
    oprot.trans.flush()
7161 
 
483 rajveer 7162 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7163 
    args = changeOrderStatus_args()
94 ashish 7164 
    args.read(iprot)
7165 
    iprot.readMessageEnd()
483 rajveer 7166 
    result = changeOrderStatus_result()
94 ashish 7167 
    try:
483 rajveer 7168 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7169 
    except TransactionServiceException, ex:
7170 
      result.ex = ex
483 rajveer 7171 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7172 
    result.write(oprot)
7173 
    oprot.writeMessageEnd()
7174 
    oprot.trans.flush()
7175 
 
483 rajveer 7176 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7177 
    args = getOrdersForTransaction_args()
94 ashish 7178 
    args.read(iprot)
7179 
    iprot.readMessageEnd()
483 rajveer 7180 
    result = getOrdersForTransaction_result()
94 ashish 7181 
    try:
1528 ankur.sing 7182 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7183 
    except TransactionServiceException, ex:
7184 
      result.ex = ex
483 rajveer 7185 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7186 
    result.write(oprot)
7187 
    oprot.writeMessageEnd()
7188 
    oprot.trans.flush()
7189 
 
483 rajveer 7190 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7191 
    args = getOrdersForCustomer_args()
94 ashish 7192 
    args.read(iprot)
7193 
    iprot.readMessageEnd()
483 rajveer 7194 
    result = getOrdersForCustomer_result()
94 ashish 7195 
    try:
3014 chandransh 7196 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7197 
    except TransactionServiceException, ex:
7198 
      result.ex = ex
483 rajveer 7199 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7200 
    result.write(oprot)
7201 
    oprot.writeMessageEnd()
7202 
    oprot.trans.flush()
7203 
 
483 rajveer 7204 
  def process_createOrder(self, seqid, iprot, oprot):
7205 
    args = createOrder_args()
94 ashish 7206 
    args.read(iprot)
7207 
    iprot.readMessageEnd()
483 rajveer 7208 
    result = createOrder_result()
94 ashish 7209 
    try:
483 rajveer 7210 
      result.success = self._handler.createOrder(args.order)
94 ashish 7211 
    except TransactionServiceException, ex:
7212 
      result.ex = ex
483 rajveer 7213 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7214 
    result.write(oprot)
7215 
    oprot.writeMessageEnd()
7216 
    oprot.trans.flush()
7217 
 
483 rajveer 7218 
  def process_getOrder(self, seqid, iprot, oprot):
7219 
    args = getOrder_args()
94 ashish 7220 
    args.read(iprot)
7221 
    iprot.readMessageEnd()
483 rajveer 7222 
    result = getOrder_result()
94 ashish 7223 
    try:
483 rajveer 7224 
      result.success = self._handler.getOrder(args.id)
94 ashish 7225 
    except TransactionServiceException, ex:
7226 
      result.ex = ex
483 rajveer 7227 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7228 
    result.write(oprot)
7229 
    oprot.writeMessageEnd()
7230 
    oprot.trans.flush()
7231 
 
483 rajveer 7232 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7233 
    args = getLineItemsForOrder_args()
94 ashish 7234 
    args.read(iprot)
7235 
    iprot.readMessageEnd()
483 rajveer 7236 
    result = getLineItemsForOrder_result()
94 ashish 7237 
    try:
483 rajveer 7238 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7239 
    except TransactionServiceException, ex:
7240 
      result.ex = ex
483 rajveer 7241 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7242 
    result.write(oprot)
7243 
    oprot.writeMessageEnd()
7244 
    oprot.trans.flush()
7245 
 
4999 phani.kuma 7246 
  def process_getOrderList(self, seqid, iprot, oprot):
7247 
    args = getOrderList_args()
7248 
    args.read(iprot)
7249 
    iprot.readMessageEnd()
7250 
    result = getOrderList_result()
7251 
    result.success = self._handler.getOrderList(args.order_ids)
7252 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7253 
    result.write(oprot)
7254 
    oprot.writeMessageEnd()
7255 
    oprot.trans.flush()
7256 
 
5386 phani.kuma 7257 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7258 
    args = getOrderListForVendor_args()
7259 
    args.read(iprot)
7260 
    iprot.readMessageEnd()
7261 
    result = getOrderListForVendor_result()
7262 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7263 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7264 
    result.write(oprot)
7265 
    oprot.writeMessageEnd()
7266 
    oprot.trans.flush()
7267 
 
1528 ankur.sing 7268 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7269 
    args = getOrderForCustomer_args()
7270 
    args.read(iprot)
7271 
    iprot.readMessageEnd()
7272 
    result = getOrderForCustomer_result()
7273 
    try:
7274 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7275 
    except TransactionServiceException, ex:
7276 
      result.ex = ex
7277 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7278 
    result.write(oprot)
7279 
    oprot.writeMessageEnd()
7280 
    oprot.trans.flush()
7281 
 
3064 chandransh 7282 
  def process_getAlerts(self, seqid, iprot, oprot):
7283 
    args = getAlerts_args()
7284 
    args.read(iprot)
7285 
    iprot.readMessageEnd()
7286 
    result = getAlerts_result()
4444 rajveer 7287 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7288 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7289 
    result.write(oprot)
7290 
    oprot.writeMessageEnd()
7291 
    oprot.trans.flush()
7292 
 
4394 rajveer 7293 
  def process_addAlert(self, seqid, iprot, oprot):
7294 
    args = addAlert_args()
3064 chandransh 7295 
    args.read(iprot)
7296 
    iprot.readMessageEnd()
4394 rajveer 7297 
    result = addAlert_result()
4444 rajveer 7298 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7299 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7300 
    result.write(oprot)
7301 
    oprot.writeMessageEnd()
7302 
    oprot.trans.flush()
7303 
 
4444 rajveer 7304 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7305 
    args = markAlertsAsSeen_args()
7306 
    args.read(iprot)
7307 
    iprot.readMessageEnd()
7308 
    result = markAlertsAsSeen_result()
7309 
    self._handler.markAlertsAsSeen(args.warehouseId)
7310 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7311 
    result.write(oprot)
7312 
    oprot.writeMessageEnd()
7313 
    oprot.trans.flush()
7314 
 
3064 chandransh 7315 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7316 
    args = getValidOrderCount_args()
7317 
    args.read(iprot)
7318 
    iprot.readMessageEnd()
7319 
    result = getValidOrderCount_result()
7320 
    result.success = self._handler.getValidOrderCount()
7321 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7322 
    result.write(oprot)
7323 
    oprot.writeMessageEnd()
7324 
    oprot.trans.flush()
7325 
 
7326 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7327 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7328 
    args.read(iprot)
7329 
    iprot.readMessageEnd()
7330 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7331 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7332 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7333 
    result.write(oprot)
7334 
    oprot.writeMessageEnd()
7335 
    oprot.trans.flush()
7336 
 
7337 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7338 
    args = getValidOrdersAmountRange_args()
7339 
    args.read(iprot)
7340 
    iprot.readMessageEnd()
7341 
    result = getValidOrdersAmountRange_result()
7342 
    result.success = self._handler.getValidOrdersAmountRange()
7343 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7344 
    result.write(oprot)
7345 
    oprot.writeMessageEnd()
7346 
    oprot.trans.flush()
7347 
 
7348 
  def process_getValidOrders(self, seqid, iprot, oprot):
7349 
    args = getValidOrders_args()
7350 
    args.read(iprot)
7351 
    iprot.readMessageEnd()
7352 
    result = getValidOrders_result()
5874 rajveer 7353 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7354 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7355 
    result.write(oprot)
7356 
    oprot.writeMessageEnd()
7357 
    oprot.trans.flush()
7358 
 
1220 chandransh 7359 
  def process_batchOrders(self, seqid, iprot, oprot):
7360 
    args = batchOrders_args()
7361 
    args.read(iprot)
7362 
    iprot.readMessageEnd()
7363 
    result = batchOrders_result()
7364 
    try:
7365 
      result.success = self._handler.batchOrders(args.warehouseId)
7366 
    except TransactionServiceException, ex:
7367 
      result.ex = ex
7368 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7369 
    result.write(oprot)
7370 
    oprot.writeMessageEnd()
7371 
    oprot.trans.flush()
7372 
 
1208 chandransh 7373 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7374 
    args = markOrderAsOutOfStock_args()
7375 
    args.read(iprot)
7376 
    iprot.readMessageEnd()
7377 
    result = markOrderAsOutOfStock_result()
7378 
    try:
7379 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7380 
    except TransactionServiceException, ex:
7381 
      result.ex = ex
7382 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7383 
    result.write(oprot)
7384 
    oprot.writeMessageEnd()
7385 
    oprot.trans.flush()
7386 
 
3064 chandransh 7387 
  def process_verifyOrder(self, seqid, iprot, oprot):
7388 
    args = verifyOrder_args()
759 chandransh 7389 
    args.read(iprot)
7390 
    iprot.readMessageEnd()
3064 chandransh 7391 
    result = verifyOrder_result()
759 chandransh 7392 
    try:
3064 chandransh 7393 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7394 
    except TransactionServiceException, ex:
7395 
      result.ex = ex
3064 chandransh 7396 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7397 
    result.write(oprot)
7398 
    oprot.writeMessageEnd()
7399 
    oprot.trans.flush()
7400 
 
3064 chandransh 7401 
  def process_acceptOrder(self, seqid, iprot, oprot):
7402 
    args = acceptOrder_args()
1113 chandransh 7403 
    args.read(iprot)
7404 
    iprot.readMessageEnd()
3064 chandransh 7405 
    result = acceptOrder_result()
1113 chandransh 7406 
    try:
3064 chandransh 7407 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7408 
    except TransactionServiceException, ex:
7409 
      result.ex = ex
3064 chandransh 7410 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7411 
    result.write(oprot)
7412 
    oprot.writeMessageEnd()
7413 
    oprot.trans.flush()
7414 
 
3064 chandransh 7415 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7416 
    args = addBillingDetails_args()
1135 chandransh 7417 
    args.read(iprot)
7418 
    iprot.readMessageEnd()
3064 chandransh 7419 
    result = addBillingDetails_result()
1135 chandransh 7420 
    try:
5110 mandeep.dh 7421 
      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 7422 
    except TransactionServiceException, ex:
7423 
      result.ex = ex
3064 chandransh 7424 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7425 
    result.write(oprot)
7426 
    oprot.writeMessageEnd()
7427 
    oprot.trans.flush()
7428 
 
4579 rajveer 7429 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7430 
    args = addInvoiceNumber_args()
7431 
    args.read(iprot)
7432 
    iprot.readMessageEnd()
7433 
    result = addInvoiceNumber_result()
7434 
    try:
6756 amar.kumar 7435 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7436 
    except TransactionServiceException, ex:
7437 
      result.ex = ex
7438 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7439 
    result.write(oprot)
7440 
    oprot.writeMessageEnd()
7441 
    oprot.trans.flush()
7442 
 
4410 rajveer 7443 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7444 
    args = markOrdersAsShippedFromWarehouse_args()
7445 
    args.read(iprot)
7446 
    iprot.readMessageEnd()
7447 
    result = markOrdersAsShippedFromWarehouse_result()
7448 
    try:
4789 rajveer 7449 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7450 
    except TransactionServiceException, ex:
7451 
      result.ex = ex
7452 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7453 
    result.write(oprot)
7454 
    oprot.writeMessageEnd()
7455 
    oprot.trans.flush()
7456 
 
5676 rajveer 7457 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7458 
    args = markOrdersAsReturnedFromStore_args()
7459 
    args.read(iprot)
7460 
    iprot.readMessageEnd()
7461 
    result = markOrdersAsReturnedFromStore_result()
7462 
    try:
5713 rajveer 7463 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7464 
    except TransactionServiceException, ex:
7465 
      result.ex = ex
7466 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7467 
    result.write(oprot)
7468 
    oprot.writeMessageEnd()
7469 
    oprot.trans.flush()
7470 
 
3064 chandransh 7471 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7472 
    args = markOrdersAsPickedUp_args()
304 ashish 7473 
    args.read(iprot)
7474 
    iprot.readMessageEnd()
3064 chandransh 7475 
    result = markOrdersAsPickedUp_result()
7476 
    try:
4910 phani.kuma 7477 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7478 
    except TransactionServiceException, ex:
7479 
      result.ex = ex
7480 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7481 
    result.write(oprot)
7482 
    oprot.writeMessageEnd()
7483 
    oprot.trans.flush()
94 ashish 7484 
 
4910 phani.kuma 7485 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7486 
    args = getOrdersNotPickedUp_args()
7487 
    args.read(iprot)
7488 
    iprot.readMessageEnd()
7489 
    result = getOrdersNotPickedUp_result()
7490 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7491 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7492 
    result.write(oprot)
7493 
    oprot.writeMessageEnd()
7494 
    oprot.trans.flush()
7495 
 
3064 chandransh 7496 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7497 
    args = markOrdersAsDelivered_args()
304 ashish 7498 
    args.read(iprot)
7499 
    iprot.readMessageEnd()
3064 chandransh 7500 
    result = markOrdersAsDelivered_result()
7501 
    try:
7502 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7503 
    except TransactionServiceException, ex:
7504 
      result.ex = ex
7505 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7506 
    result.write(oprot)
7507 
    oprot.writeMessageEnd()
7508 
    oprot.trans.flush()
7509 
 
4910 phani.kuma 7510 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7511 
    args = markAsRTOrders_args()
1596 ankur.sing 7512 
    args.read(iprot)
7513 
    iprot.readMessageEnd()
4910 phani.kuma 7514 
    result = markAsRTOrders_result()
3064 chandransh 7515 
    try:
4910 phani.kuma 7516 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7517 
    except TransactionServiceException, ex:
7518 
      result.ex = ex
4910 phani.kuma 7519 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7520 
    result.write(oprot)
7521 
    oprot.writeMessageEnd()
7522 
    oprot.trans.flush()
304 ashish 7523 
 
4910 phani.kuma 7524 
  def process_getRTOrders(self, seqid, iprot, oprot):
7525 
    args = getRTOrders_args()
7526 
    args.read(iprot)
7527 
    iprot.readMessageEnd()
7528 
    result = getRTOrders_result()
7529 
    result.success = self._handler.getRTOrders(args.providerId)
7530 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7531 
    result.write(oprot)
7532 
    oprot.writeMessageEnd()
7533 
    oprot.trans.flush()
7534 
 
3064 chandransh 7535 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7536 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7537 
    args.read(iprot)
7538 
    iprot.readMessageEnd()
3064 chandransh 7539 
    result = updateNonDeliveryReason_result()
7540 
    try:
4910 phani.kuma 7541 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7542 
    except TransactionServiceException, ex:
7543 
      result.ex = ex
7544 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7545 
    result.write(oprot)
7546 
    oprot.writeMessageEnd()
7547 
    oprot.trans.flush()
1596 ankur.sing 7548 
 
4910 phani.kuma 7549 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7550 
    args = getNonDeliveredOrdersbyCourier_args()
7551 
    args.read(iprot)
7552 
    iprot.readMessageEnd()
7553 
    result = getNonDeliveredOrdersbyCourier_result()
7554 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7555 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7556 
    result.write(oprot)
7557 
    oprot.writeMessageEnd()
7558 
    oprot.trans.flush()
7559 
 
7560 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7561 
    args = markOrdersAsLocalConnected_args()
7562 
    args.read(iprot)
7563 
    iprot.readMessageEnd()
7564 
    result = markOrdersAsLocalConnected_result()
7565 
    try:
7566 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7567 
    except TransactionServiceException, ex:
7568 
      result.ex = ex
7569 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7570 
    result.write(oprot)
7571 
    oprot.writeMessageEnd()
7572 
    oprot.trans.flush()
7573 
 
7574 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7575 
    args = getOrdersNotLocalConnected_args()
7576 
    args.read(iprot)
7577 
    iprot.readMessageEnd()
7578 
    result = getOrdersNotLocalConnected_result()
7579 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7580 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7581 
    result.write(oprot)
7582 
    oprot.writeMessageEnd()
7583 
    oprot.trans.flush()
7584 
 
7585 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7586 
    args = markOrdersAsDestinationCityReached_args()
7587 
    args.read(iprot)
7588 
    iprot.readMessageEnd()
7589 
    result = markOrdersAsDestinationCityReached_result()
7590 
    try:
7591 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7592 
    except TransactionServiceException, ex:
7593 
      result.ex = ex
7594 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7595 
    result.write(oprot)
7596 
    oprot.writeMessageEnd()
7597 
    oprot.trans.flush()
7598 
 
7599 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7600 
    args = markOrdersAsFirstDeliveryAttempted_args()
7601 
    args.read(iprot)
7602 
    iprot.readMessageEnd()
7603 
    result = markOrdersAsFirstDeliveryAttempted_result()
7604 
    try:
7605 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7606 
    except TransactionServiceException, ex:
7607 
      result.ex = ex
7608 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7609 
    result.write(oprot)
7610 
    oprot.writeMessageEnd()
7611 
    oprot.trans.flush()
7612 
 
3064 chandransh 7613 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7614 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7615 
    args.read(iprot)
7616 
    iprot.readMessageEnd()
3064 chandransh 7617 
    result = getUndeliveredOrders_result()
7618 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7619 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7620 
    result.write(oprot)
7621 
    oprot.writeMessageEnd()
7622 
    oprot.trans.flush()
7623 
 
4783 phani.kuma 7624 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7625 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7626 
    args.read(iprot)
7627 
    iprot.readMessageEnd()
7628 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7629 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7630 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7631 
    result.write(oprot)
7632 
    oprot.writeMessageEnd()
7633 
    oprot.trans.flush()
7634 
 
2536 chandransh 7635 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7636 
    args = toggleDOAFlag_args()
7637 
    args.read(iprot)
7638 
    iprot.readMessageEnd()
7639 
    result = toggleDOAFlag_result()
7640 
    try:
7641 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7642 
    except TransactionServiceException, ex:
7643 
      result.ex = ex
7644 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7645 
    result.write(oprot)
7646 
    oprot.writeMessageEnd()
7647 
    oprot.trans.flush()
1886 ankur.sing 7648 
 
4712 rajveer 7649 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7650 
    args = markOrderAsDelivered_args()
7651 
    args.read(iprot)
7652 
    iprot.readMessageEnd()
7653 
    result = markOrderAsDelivered_result()
7654 
    try:
7655 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7656 
    except TransactionServiceException, ex:
7657 
      result.ex = ex
7658 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7659 
    result.write(oprot)
7660 
    oprot.writeMessageEnd()
7661 
    oprot.trans.flush()
7662 
 
5553 rajveer 7663 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7664 
    args = markOrderAsReceivedAtStore_args()
7665 
    args.read(iprot)
7666 
    iprot.readMessageEnd()
7667 
    result = markOrderAsReceivedAtStore_result()
7668 
    try:
7669 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7670 
    except TransactionServiceException, ex:
7671 
      result.ex = ex
7672 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7673 
    result.write(oprot)
7674 
    oprot.writeMessageEnd()
7675 
    oprot.trans.flush()
7676 
 
4454 rajveer 7677 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7678 
    args = markOrderDoaRequestReceived_args()
7679 
    args.read(iprot)
7680 
    iprot.readMessageEnd()
7681 
    result = markOrderDoaRequestReceived_result()
7682 
    try:
7683 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7684 
    except TransactionServiceException, ex:
7685 
      result.ex = ex
7686 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7687 
    result.write(oprot)
7688 
    oprot.writeMessageEnd()
7689 
    oprot.trans.flush()
7690 
 
7691 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7692 
    args = markOrderDoaRequestAuthorized_args()
7693 
    args.read(iprot)
7694 
    iprot.readMessageEnd()
7695 
    result = markOrderDoaRequestAuthorized_result()
7696 
    try:
7697 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7698 
    except TransactionServiceException, ex:
7699 
      result.ex = ex
7700 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7701 
    result.write(oprot)
7702 
    oprot.writeMessageEnd()
7703 
    oprot.trans.flush()
7704 
 
4488 rajveer 7705 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7706 
    args = markOrderReturnRequestReceived_args()
7707 
    args.read(iprot)
7708 
    iprot.readMessageEnd()
7709 
    result = markOrderReturnRequestReceived_result()
7710 
    try:
7711 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7712 
    except TransactionServiceException, ex:
7713 
      result.ex = ex
7714 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7715 
    result.write(oprot)
7716 
    oprot.writeMessageEnd()
7717 
    oprot.trans.flush()
7718 
 
7719 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7720 
    args = markOrderReturnRequestAuthorized_args()
7721 
    args.read(iprot)
7722 
    iprot.readMessageEnd()
7723 
    result = markOrderReturnRequestAuthorized_result()
7724 
    try:
7725 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7726 
    except TransactionServiceException, ex:
7727 
      result.ex = ex
7728 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7729 
    result.write(oprot)
7730 
    oprot.writeMessageEnd()
7731 
    oprot.trans.flush()
7732 
 
2536 chandransh 7733 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7734 
    args = requestPickupNumber_args()
7735 
    args.read(iprot)
7736 
    iprot.readMessageEnd()
7737 
    result = requestPickupNumber_result()
7738 
    try:
4579 rajveer 7739 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7740 
    except TransactionServiceException, ex:
7741 
      result.ex = ex
7742 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7743 
    result.write(oprot)
7744 
    oprot.writeMessageEnd()
7745 
    oprot.trans.flush()
7746 
 
7747 
  def process_authorizePickup(self, seqid, iprot, oprot):
7748 
    args = authorizePickup_args()
7749 
    args.read(iprot)
7750 
    iprot.readMessageEnd()
7751 
    result = authorizePickup_result()
7752 
    try:
4602 rajveer 7753 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7754 
    except TransactionServiceException, ex:
7755 
      result.ex = ex
7756 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7757 
    result.write(oprot)
7758 
    oprot.writeMessageEnd()
7759 
    oprot.trans.flush()
7760 
 
2764 chandransh 7761 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7762 
    args = markDoasAsPickedUp_args()
7763 
    args.read(iprot)
7764 
    iprot.readMessageEnd()
7765 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7766 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7767 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7768 
    result.write(oprot)
7769 
    oprot.writeMessageEnd()
7770 
    oprot.trans.flush()
7771 
 
4910 phani.kuma 7772 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7773 
    args = getDoasNotPickedUp_args()
7774 
    args.read(iprot)
7775 
    iprot.readMessageEnd()
7776 
    result = getDoasNotPickedUp_result()
7777 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7778 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7779 
    result.write(oprot)
7780 
    oprot.writeMessageEnd()
7781 
    oprot.trans.flush()
7782 
 
4741 phani.kuma 7783 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7784 
    args = markReturnOrdersAsPickedUp_args()
7785 
    args.read(iprot)
7786 
    iprot.readMessageEnd()
7787 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7788 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7789 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7790 
    result.write(oprot)
7791 
    oprot.writeMessageEnd()
7792 
    oprot.trans.flush()
7793 
 
4910 phani.kuma 7794 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7795 
    args = getReturnOrdersNotPickedUp_args()
7796 
    args.read(iprot)
7797 
    iprot.readMessageEnd()
7798 
    result = getReturnOrdersNotPickedUp_result()
7799 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7800 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7801 
    result.write(oprot)
7802 
    oprot.writeMessageEnd()
7803 
    oprot.trans.flush()
7804 
 
2616 chandransh 7805 
  def process_receiveReturn(self, seqid, iprot, oprot):
7806 
    args = receiveReturn_args()
2591 chandransh 7807 
    args.read(iprot)
7808 
    iprot.readMessageEnd()
2616 chandransh 7809 
    result = receiveReturn_result()
2591 chandransh 7810 
    try:
4479 rajveer 7811 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7812 
    except TransactionServiceException, ex:
7813 
      result.ex = ex
2616 chandransh 7814 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7815 
    result.write(oprot)
7816 
    oprot.writeMessageEnd()
7817 
    oprot.trans.flush()
2536 chandransh 7818 
 
2591 chandransh 7819 
  def process_validateDoa(self, seqid, iprot, oprot):
7820 
    args = validateDoa_args()
7821 
    args.read(iprot)
7822 
    iprot.readMessageEnd()
7823 
    result = validateDoa_result()
7824 
    try:
7825 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7826 
    except TransactionServiceException, ex:
7827 
      result.ex = ex
7828 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7829 
    result.write(oprot)
7830 
    oprot.writeMessageEnd()
7831 
    oprot.trans.flush()
7832 
 
4495 rajveer 7833 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7834 
    args = validateReturnProduct_args()
7835 
    args.read(iprot)
7836 
    iprot.readMessageEnd()
7837 
    result = validateReturnProduct_result()
7838 
    try:
7839 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7840 
    except TransactionServiceException, ex:
7841 
      result.ex = ex
7842 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7843 
    result.write(oprot)
7844 
    oprot.writeMessageEnd()
7845 
    oprot.trans.flush()
7846 
 
2616 chandransh 7847 
  def process_reshipOrder(self, seqid, iprot, oprot):
7848 
    args = reshipOrder_args()
7849 
    args.read(iprot)
7850 
    iprot.readMessageEnd()
7851 
    result = reshipOrder_result()
7852 
    try:
7853 
      result.success = self._handler.reshipOrder(args.orderId)
7854 
    except TransactionServiceException, ex:
7855 
      result.ex = ex
7856 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7857 
    result.write(oprot)
7858 
    oprot.writeMessageEnd()
7859 
    oprot.trans.flush()
2591 chandransh 7860 
 
2616 chandransh 7861 
  def process_refundOrder(self, seqid, iprot, oprot):
7862 
    args = refundOrder_args()
7863 
    args.read(iprot)
7864 
    iprot.readMessageEnd()
7865 
    result = refundOrder_result()
7866 
    try:
3226 chandransh 7867 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7868 
    except TransactionServiceException, ex:
7869 
      result.ex = ex
7870 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7871 
    result.write(oprot)
7872 
    oprot.writeMessageEnd()
7873 
    oprot.trans.flush()
7874 
 
2690 chandransh 7875 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7876 
    args = getReturnOrders_args()
7877 
    args.read(iprot)
7878 
    iprot.readMessageEnd()
7879 
    result = getReturnOrders_result()
7880 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7881 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7882 
    result.write(oprot)
7883 
    oprot.writeMessageEnd()
7884 
    oprot.trans.flush()
2616 chandransh 7885 
 
5481 phani.kuma 7886 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7887 
    args = getAllReturnOrders_args()
7888 
    args.read(iprot)
7889 
    iprot.readMessageEnd()
7890 
    result = getAllReturnOrders_result()
7891 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7892 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7893 
    result.write(oprot)
7894 
    oprot.writeMessageEnd()
7895 
    oprot.trans.flush()
7896 
 
2700 chandransh 7897 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7898 
    args = getReturnOrder_args()
7899 
    args.read(iprot)
7900 
    iprot.readMessageEnd()
7901 
    result = getReturnOrder_result()
7902 
    try:
7903 
      result.success = self._handler.getReturnOrder(args.id)
7904 
    except TransactionServiceException, ex:
7905 
      result.ex = ex
7906 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7907 
    result.write(oprot)
7908 
    oprot.writeMessageEnd()
7909 
    oprot.trans.flush()
7910 
 
2690 chandransh 7911 
  def process_processReturn(self, seqid, iprot, oprot):
7912 
    args = processReturn_args()
7913 
    args.read(iprot)
7914 
    iprot.readMessageEnd()
7915 
    result = processReturn_result()
7916 
    try:
7917 
      self._handler.processReturn(args.returnOrderId)
7918 
    except TransactionServiceException, ex:
7919 
      result.ex = ex
7920 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7921 
    result.write(oprot)
7922 
    oprot.writeMessageEnd()
7923 
    oprot.trans.flush()
7924 
 
3451 chandransh 7925 
  def process_updateWeight(self, seqid, iprot, oprot):
7926 
    args = updateWeight_args()
7927 
    args.read(iprot)
7928 
    iprot.readMessageEnd()
7929 
    result = updateWeight_result()
7930 
    try:
7931 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7932 
    except TransactionServiceException, ex:
7933 
      result.ex = ex
7934 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7935 
    result.write(oprot)
7936 
    oprot.writeMessageEnd()
7937 
    oprot.trans.flush()
2819 chandransh 7938 
 
3469 chandransh 7939 
  def process_changeItem(self, seqid, iprot, oprot):
7940 
    args = changeItem_args()
7941 
    args.read(iprot)
7942 
    iprot.readMessageEnd()
7943 
    result = changeItem_result()
7944 
    try:
7945 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7946 
    except TransactionServiceException, ex:
7947 
      result.ex = ex
7948 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7949 
    result.write(oprot)
7950 
    oprot.writeMessageEnd()
7951 
    oprot.trans.flush()
3451 chandransh 7952 
 
3469 chandransh 7953 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7954 
    args = shiftToWarehouse_args()
7955 
    args.read(iprot)
7956 
    iprot.readMessageEnd()
7957 
    result = shiftToWarehouse_result()
7958 
    try:
7959 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7960 
    except TransactionServiceException, ex:
7961 
      result.ex = ex
7962 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7963 
    result.write(oprot)
7964 
    oprot.writeMessageEnd()
7965 
    oprot.trans.flush()
7966 
 
3553 chandransh 7967 
  def process_addDelayReason(self, seqid, iprot, oprot):
7968 
    args = addDelayReason_args()
7969 
    args.read(iprot)
7970 
    iprot.readMessageEnd()
7971 
    result = addDelayReason_result()
7972 
    try:
4647 rajveer 7973 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7974 
    except TransactionServiceException, ex:
7975 
      result.ex = ex
7976 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7977 
    result.write(oprot)
7978 
    oprot.writeMessageEnd()
7979 
    oprot.trans.flush()
3469 chandransh 7980 
 
3956 chandransh 7981 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7982 
    args = reconcileCodCollection_args()
7983 
    args.read(iprot)
7984 
    iprot.readMessageEnd()
7985 
    result = reconcileCodCollection_result()
7986 
    try:
7987 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7988 
    except TransactionServiceException, ex:
7989 
      result.ex = ex
7990 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7991 
    result.write(oprot)
7992 
    oprot.writeMessageEnd()
7993 
    oprot.trans.flush()
3553 chandransh 7994 
 
4008 mandeep.dh 7995 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7996 
    args = getTransactionsRequiringExtraProcessing_args()
7997 
    args.read(iprot)
7998 
    iprot.readMessageEnd()
7999 
    result = getTransactionsRequiringExtraProcessing_result()
8000 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8001 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8002 
    result.write(oprot)
8003 
    oprot.writeMessageEnd()
8004 
    oprot.trans.flush()
3956 chandransh 8005 
 
4008 mandeep.dh 8006 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8007 
    args = markTransactionAsProcessed_args()
8008 
    args.read(iprot)
8009 
    iprot.readMessageEnd()
8010 
    result = markTransactionAsProcessed_result()
8011 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8012 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8013 
    result.write(oprot)
8014 
    oprot.writeMessageEnd()
8015 
    oprot.trans.flush()
8016 
 
4018 chandransh 8017 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8018 
    args = getItemWiseRiskyOrdersCount_args()
8019 
    args.read(iprot)
8020 
    iprot.readMessageEnd()
8021 
    result = getItemWiseRiskyOrdersCount_result()
8022 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8023 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8024 
    result.write(oprot)
8025 
    oprot.writeMessageEnd()
8026 
    oprot.trans.flush()
4008 mandeep.dh 8027 
 
4295 varun.gupt 8028 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8029 
    args = getOrdersForItemIds_args()
8030 
    args.read(iprot)
8031 
    iprot.readMessageEnd()
8032 
    result = getOrdersForItemIds_result()
8033 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8034 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8035 
    result.write(oprot)
8036 
    oprot.writeMessageEnd()
8037 
    oprot.trans.flush()
8038 
 
4247 rajveer 8039 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8040 
    args = markOrderCancellationRequestReceived_args()
8041 
    args.read(iprot)
8042 
    iprot.readMessageEnd()
8043 
    result = markOrderCancellationRequestReceived_result()
8044 
    try:
8045 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8046 
    except TransactionServiceException, ex:
8047 
      result.ex = ex
8048 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8049 
    result.write(oprot)
8050 
    oprot.writeMessageEnd()
8051 
    oprot.trans.flush()
4018 chandransh 8052 
 
4247 rajveer 8053 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8054 
    args = markOrderCancellationRequestConfirmed_args()
8055 
    args.read(iprot)
8056 
    iprot.readMessageEnd()
8057 
    result = markOrderCancellationRequestConfirmed_result()
8058 
    try:
8059 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8060 
    except TransactionServiceException, ex:
8061 
      result.ex = ex
8062 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8063 
    result.write(oprot)
8064 
    oprot.writeMessageEnd()
8065 
    oprot.trans.flush()
8066 
 
8067 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8068 
    args = markOrderCancellationRequestDenied_args()
8069 
    args.read(iprot)
8070 
    iprot.readMessageEnd()
8071 
    result = markOrderCancellationRequestDenied_result()
8072 
    try:
8073 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8074 
    except TransactionServiceException, ex:
8075 
      result.ex = ex
8076 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8077 
    result.write(oprot)
8078 
    oprot.writeMessageEnd()
8079 
    oprot.trans.flush()
8080 
 
4258 rajveer 8081 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8082 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8083 
    args.read(iprot)
8084 
    iprot.readMessageEnd()
4258 rajveer 8085 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8086 
    try:
4258 rajveer 8087 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8088 
    except TransactionServiceException, ex:
8089 
      result.ex = ex
4258 rajveer 8090 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8091 
    result.write(oprot)
8092 
    oprot.writeMessageEnd()
8093 
    oprot.trans.flush()
8094 
 
4259 anupam.sin 8095 
  def process_refundTransaction(self, seqid, iprot, oprot):
8096 
    args = refundTransaction_args()
8097 
    args.read(iprot)
8098 
    iprot.readMessageEnd()
8099 
    result = refundTransaction_result()
8100 
    try:
8101 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8102 
    except TransactionServiceException, ex:
8103 
      result.ex = ex
8104 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8105 
    result.write(oprot)
8106 
    oprot.writeMessageEnd()
8107 
    oprot.trans.flush()
4247 rajveer 8108 
 
4324 mandeep.dh 8109 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8110 
    args = updateShipmentAddress_args()
8111 
    args.read(iprot)
8112 
    iprot.readMessageEnd()
8113 
    result = updateShipmentAddress_result()
8114 
    try:
8115 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8116 
    except TransactionServiceException, ex:
8117 
      result.ex = ex
8118 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8119 
    result.write(oprot)
8120 
    oprot.writeMessageEnd()
8121 
    oprot.trans.flush()
8122 
 
4285 rajveer 8123 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8124 
    args = acceptOrdersForItemId_args()
8125 
    args.read(iprot)
8126 
    iprot.readMessageEnd()
8127 
    result = acceptOrdersForItemId_result()
8128 
    try:
8129 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8130 
    except TransactionServiceException, ex:
8131 
      result.ex = ex
8132 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8133 
    result.write(oprot)
8134 
    oprot.writeMessageEnd()
8135 
    oprot.trans.flush()
4259 anupam.sin 8136 
 
4303 rajveer 8137 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8138 
    args = markOrdersAsPORaised_args()
8139 
    args.read(iprot)
8140 
    iprot.readMessageEnd()
8141 
    result = markOrdersAsPORaised_result()
8142 
    try:
4369 rajveer 8143 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8144 
    except TransactionServiceException, ex:
8145 
      result.ex = ex
8146 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8147 
    result.write(oprot)
8148 
    oprot.writeMessageEnd()
8149 
    oprot.trans.flush()
4285 rajveer 8150 
 
4303 rajveer 8151 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8152 
    args = markOrdersAsReversalInitiated_args()
8153 
    args.read(iprot)
8154 
    iprot.readMessageEnd()
8155 
    result = markOrdersAsReversalInitiated_result()
8156 
    try:
4369 rajveer 8157 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8158 
    except TransactionServiceException, ex:
8159 
      result.ex = ex
8160 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8161 
    result.write(oprot)
8162 
    oprot.writeMessageEnd()
8163 
    oprot.trans.flush()
8164 
 
8165 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8166 
    args = markOrdersAsNotAvailabke_args()
8167 
    args.read(iprot)
8168 
    iprot.readMessageEnd()
8169 
    result = markOrdersAsNotAvailabke_result()
8170 
    try:
4369 rajveer 8171 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8172 
    except TransactionServiceException, ex:
8173 
      result.ex = ex
8174 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8175 
    result.write(oprot)
8176 
    oprot.writeMessageEnd()
8177 
    oprot.trans.flush()
8178 
 
4369 rajveer 8179 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8180 
    args = markOrdersAsTimeout_args()
8181 
    args.read(iprot)
8182 
    iprot.readMessageEnd()
8183 
    result = markOrdersAsTimeout_result()
8184 
    try:
8185 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8186 
    except TransactionServiceException, ex:
8187 
      result.ex = ex
8188 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8189 
    result.write(oprot)
8190 
    oprot.writeMessageEnd()
8191 
    oprot.trans.flush()
4303 rajveer 8192 
 
4662 rajveer 8193 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8194 
    args = markOrderAsLostInTransit_args()
8195 
    args.read(iprot)
8196 
    iprot.readMessageEnd()
8197 
    result = markOrderAsLostInTransit_result()
8198 
    try:
8199 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8200 
    except TransactionServiceException, ex:
8201 
      result.ex = ex
8202 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8203 
    result.write(oprot)
8204 
    oprot.writeMessageEnd()
8205 
    oprot.trans.flush()
8206 
 
4386 anupam.sin 8207 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8208 
    args = getOrderForAwb_args()
8209 
    args.read(iprot)
8210 
    iprot.readMessageEnd()
8211 
    result = getOrderForAwb_result()
8212 
    try:
8213 
      result.success = self._handler.getOrderForAwb(args.awb)
8214 
    except TransactionServiceException, ex:
8215 
      result.ex = ex
8216 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8217 
    result.write(oprot)
8218 
    oprot.writeMessageEnd()
8219 
    oprot.trans.flush()
4369 rajveer 8220 
 
4506 phani.kuma 8221 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8222 
    args = getOrdersForProviderForStatus_args()
8223 
    args.read(iprot)
8224 
    iprot.readMessageEnd()
8225 
    result = getOrdersForProviderForStatus_result()
8226 
    try:
4910 phani.kuma 8227 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8228 
    except TransactionServiceException, ex:
8229 
      result.ex = ex
8230 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8231 
    result.write(oprot)
8232 
    oprot.writeMessageEnd()
8233 
    oprot.trans.flush()
4386 anupam.sin 8234 
 
4600 varun.gupt 8235 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8236 
    args = getBilledOrdersForVendor_args()
8237 
    args.read(iprot)
8238 
    iprot.readMessageEnd()
8239 
    result = getBilledOrdersForVendor_result()
8240 
    try:
8241 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8242 
    except TransactionServiceException, ex:
8243 
      result.ex = ex
8244 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8245 
    result.write(oprot)
8246 
    oprot.writeMessageEnd()
8247 
    oprot.trans.flush()
4506 phani.kuma 8248 
 
4607 rajveer 8249 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8250 
    args = getSlippedSippingDateOrders_args()
8251 
    args.read(iprot)
8252 
    iprot.readMessageEnd()
8253 
    result = getSlippedSippingDateOrders_result()
8254 
    try:
8255 
      result.success = self._handler.getSlippedSippingDateOrders()
8256 
    except TransactionServiceException, ex:
8257 
      result.ex = ex
8258 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8259 
    result.write(oprot)
8260 
    oprot.writeMessageEnd()
8261 
    oprot.trans.flush()
8262 
 
4709 rajveer 8263 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8264 
    args = getCancelledOrders_args()
8265 
    args.read(iprot)
8266 
    iprot.readMessageEnd()
8267 
    result = getCancelledOrders_result()
8268 
    try:
8269 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8270 
    except TransactionServiceException, ex:
8271 
      result.ex = ex
8272 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8273 
    result.write(oprot)
8274 
    oprot.writeMessageEnd()
8275 
    oprot.trans.flush()
8276 
 
4600 varun.gupt 8277 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8278 
    args = saveBluedartSettlements_args()
8279 
    args.read(iprot)
8280 
    iprot.readMessageEnd()
8281 
    result = saveBluedartSettlements_result()
8282 
    try:
8283 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8284 
    except TransactionServiceException, ex:
8285 
      result.ex = ex
8286 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8287 
    result.write(oprot)
8288 
    oprot.writeMessageEnd()
8289 
    oprot.trans.flush()
8290 
 
8291 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8292 
    args = savePaymentSettlements_args()
8293 
    args.read(iprot)
8294 
    iprot.readMessageEnd()
8295 
    result = savePaymentSettlements_result()
8296 
    try:
4905 varun.gupt 8297 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8298 
    except TransactionServiceException, ex:
8299 
      result.ex = ex
8300 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8301 
    result.write(oprot)
8302 
    oprot.writeMessageEnd()
8303 
    oprot.trans.flush()
8304 
 
8305 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8306 
    args = saveEBSSettlementSummary_args()
8307 
    args.read(iprot)
8308 
    iprot.readMessageEnd()
8309 
    result = saveEBSSettlementSummary_result()
8310 
    try:
8311 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8312 
    except TransactionServiceException, ex:
8313 
      result.ex = ex
8314 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8315 
    result.write(oprot)
8316 
    oprot.writeMessageEnd()
8317 
    oprot.trans.flush()
8318 
 
5386 phani.kuma 8319 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8320 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8321 
    args.read(iprot)
8322 
    iprot.readMessageEnd()
5386 phani.kuma 8323 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8324 
    try:
5386 phani.kuma 8325 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8326 
    except TransactionServiceException, ex:
8327 
      result.ex = ex
5386 phani.kuma 8328 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8329 
    result.write(oprot)
8330 
    oprot.writeMessageEnd()
8331 
    oprot.trans.flush()
8332 
 
5386 phani.kuma 8333 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8334 
    args = getSettlementForCod_args()
8335 
    args.read(iprot)
8336 
    iprot.readMessageEnd()
8337 
    result = getSettlementForCod_result()
8338 
    try:
8339 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8340 
    except TransactionServiceException, ex:
8341 
      result.ex = ex
8342 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8343 
    result.write(oprot)
8344 
    oprot.writeMessageEnd()
8345 
    oprot.trans.flush()
8346 
 
4600 varun.gupt 8347 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8348 
    args = getEBSSettlementSummaries_args()
8349 
    args.read(iprot)
8350 
    iprot.readMessageEnd()
8351 
    result = getEBSSettlementSummaries_result()
8352 
    try:
8353 
      result.success = self._handler.getEBSSettlementSummaries()
8354 
    except TransactionServiceException, ex:
8355 
      result.ex = ex
8356 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8357 
    result.write(oprot)
8358 
    oprot.writeMessageEnd()
8359 
    oprot.trans.flush()
8360 
 
8361 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8362 
    args = markEBSSettlementUploaded_args()
8363 
    args.read(iprot)
8364 
    iprot.readMessageEnd()
8365 
    result = markEBSSettlementUploaded_result()
8366 
    try:
8367 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8368 
    except TransactionServiceException, ex:
8369 
      result.ex = ex
8370 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8371 
    result.write(oprot)
8372 
    oprot.writeMessageEnd()
8373 
    oprot.trans.flush()
8374 
 
8375 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8376 
    args = getEBSSettlementDate_args()
8377 
    args.read(iprot)
8378 
    iprot.readMessageEnd()
8379 
    result = getEBSSettlementDate_result()
8380 
    try:
8381 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8382 
    except TransactionServiceException, ex:
8383 
      result.ex = ex
8384 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8385 
    result.write(oprot)
8386 
    oprot.writeMessageEnd()
8387 
    oprot.trans.flush()
8388 
 
4715 varun.gupt 8389 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8390 
    args = getSettlementsByDate_args()
8391 
    args.read(iprot)
8392 
    iprot.readMessageEnd()
8393 
    result = getSettlementsByDate_result()
8394 
    try:
8395 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8396 
    except TransactionServiceException, ex:
8397 
      result.ex = ex
8398 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8399 
    result.write(oprot)
8400 
    oprot.writeMessageEnd()
8401 
    oprot.trans.flush()
4600 varun.gupt 8402 
 
4715 varun.gupt 8403 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8404 
    args = getReshippedOrderIds_args()
8405 
    args.read(iprot)
8406 
    iprot.readMessageEnd()
8407 
    result = getReshippedOrderIds_result()
8408 
    try:
8409 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8410 
    except TransactionServiceException, ex:
8411 
      result.ex = ex
8412 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8413 
    result.write(oprot)
8414 
    oprot.writeMessageEnd()
8415 
    oprot.trans.flush()
8416 
 
5481 phani.kuma 8417 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8418 
    args = getBilledOrders_args()
4875 varun.gupt 8419 
    args.read(iprot)
8420 
    iprot.readMessageEnd()
5481 phani.kuma 8421 
    result = getBilledOrders_result()
4875 varun.gupt 8422 
    try:
5481 phani.kuma 8423 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8424 
    except TransactionServiceException, ex:
8425 
      result.ex = ex
5481 phani.kuma 8426 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8427 
    result.write(oprot)
8428 
    oprot.writeMessageEnd()
8429 
    oprot.trans.flush()
4757 mandeep.dh 8430 
 
5031 varun.gupt 8431 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8432 
    args = getStatusDistributionOfOrders_args()
8433 
    args.read(iprot)
8434 
    iprot.readMessageEnd()
8435 
    result = getStatusDistributionOfOrders_result()
8436 
    try:
8437 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8438 
    except TransactionServiceException, ex:
8439 
      result.ex = ex
8440 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8441 
    result.write(oprot)
8442 
    oprot.writeMessageEnd()
8443 
    oprot.trans.flush()
4875 varun.gupt 8444 
 
5067 varun.gupt 8445 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8446 
    args = getOrderIdsForStatus_args()
8447 
    args.read(iprot)
8448 
    iprot.readMessageEnd()
8449 
    result = getOrderIdsForStatus_result()
8450 
    try:
8451 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8452 
    except TransactionServiceException, ex:
8453 
      result.ex = ex
8454 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8455 
    result.write(oprot)
8456 
    oprot.writeMessageEnd()
8457 
    oprot.trans.flush()
5031 varun.gupt 8458 
 
5348 anupam.sin 8459 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8460 
    args = updateCODAgent_args()
8461 
    args.read(iprot)
8462 
    iprot.readMessageEnd()
8463 
    result = updateCODAgent_result()
8464 
    try:
8465 
      self._handler.updateCODAgent(args.agent, args.orderId)
8466 
    except TransactionServiceException, ex:
8467 
      result.ex = ex
8468 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8469 
    result.write(oprot)
8470 
    oprot.writeMessageEnd()
8471 
    oprot.trans.flush()
8472 
 
5099 varun.gupt 8473 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8474 
    args = updateOrderAsPaidToVendor_args()
8475 
    args.read(iprot)
8476 
    iprot.readMessageEnd()
8477 
    result = updateOrderAsPaidToVendor_result()
8478 
    try:
8479 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8480 
    except TransactionServiceException, ex:
8481 
      result.ex = ex
8482 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8483 
    result.write(oprot)
8484 
    oprot.writeMessageEnd()
8485 
    oprot.trans.flush()
5067 varun.gupt 8486 
 
5386 phani.kuma 8487 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8488 
    args = updateOrderOnlyAsPaidToVendor_args()
8489 
    args.read(iprot)
8490 
    iprot.readMessageEnd()
8491 
    result = updateOrderOnlyAsPaidToVendor_result()
8492 
    try:
8493 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8494 
    except TransactionServiceException, ex:
8495 
      result.ex = ex
8496 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8497 
    result.write(oprot)
8498 
    oprot.writeMessageEnd()
8499 
    oprot.trans.flush()
8500 
 
5208 varun.gupt 8501 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8502 
    args = getRefundedOrdersMarkedPaid_args()
8503 
    args.read(iprot)
8504 
    iprot.readMessageEnd()
8505 
    result = getRefundedOrdersMarkedPaid_result()
8506 
    try:
8507 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8508 
    except TransactionServiceException, ex:
8509 
      result.ex = ex
8510 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8511 
    result.write(oprot)
8512 
    oprot.writeMessageEnd()
8513 
    oprot.trans.flush()
5099 varun.gupt 8514 
 
5447 anupam.sin 8515 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8516 
    args = getAllVerificationAgents_args()
8517 
    args.read(iprot)
8518 
    iprot.readMessageEnd()
8519 
    result = getAllVerificationAgents_result()
8520 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8521 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8522 
    result.write(oprot)
8523 
    oprot.writeMessageEnd()
8524 
    oprot.trans.flush()
5208 varun.gupt 8525 
 
5527 anupam.sin 8526 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8527 
    args = getAllAttributesForOrderId_args()
8528 
    args.read(iprot)
8529 
    iprot.readMessageEnd()
8530 
    result = getAllAttributesForOrderId_result()
8531 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8532 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8533 
    result.write(oprot)
8534 
    oprot.writeMessageEnd()
8535 
    oprot.trans.flush()
5447 anupam.sin 8536 
 
5676 rajveer 8537 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8538 
    args = setOrderAttributes_args()
8539 
    args.read(iprot)
8540 
    iprot.readMessageEnd()
8541 
    result = setOrderAttributes_result()
8542 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8543 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8544 
    result.write(oprot)
8545 
    oprot.writeMessageEnd()
8546 
    oprot.trans.flush()
8547 
 
5527 anupam.sin 8548 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8549 
    args = setOrderAttributeForTransaction_args()
8550 
    args.read(iprot)
8551 
    iprot.readMessageEnd()
8552 
    result = setOrderAttributeForTransaction_result()
8553 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8554 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8555 
    result.write(oprot)
8556 
    oprot.writeMessageEnd()
8557 
    oprot.trans.flush()
8558 
 
5553 rajveer 8559 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8560 
    args = getReceivePendingOrders_args()
8561 
    args.read(iprot)
8562 
    iprot.readMessageEnd()
8563 
    result = getReceivePendingOrders_result()
8564 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8565 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8566 
    result.write(oprot)
8567 
    oprot.writeMessageEnd()
8568 
    oprot.trans.flush()
5527 anupam.sin 8569 
 
5553 rajveer 8570 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8571 
    args = getReceivedAtStoreOrders_args()
8572 
    args.read(iprot)
8573 
    iprot.readMessageEnd()
8574 
    result = getReceivedAtStoreOrders_result()
8575 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8576 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8577 
    result.write(oprot)
8578 
    oprot.writeMessageEnd()
8579 
    oprot.trans.flush()
8580 
 
5713 rajveer 8581 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8582 
    args = getOrdersCollectionAtStore_args()
8583 
    args.read(iprot)
8584 
    iprot.readMessageEnd()
8585 
    result = getOrdersCollectionAtStore_result()
8586 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8587 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8588 
    result.write(oprot)
8589 
    oprot.writeMessageEnd()
8590 
    oprot.trans.flush()
8591 
 
5833 rajveer 8592 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8593 
    args = getOrderAttributeValue_args()
8594 
    args.read(iprot)
8595 
    iprot.readMessageEnd()
8596 
    result = getOrderAttributeValue_result()
8597 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8598 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8599 
    result.write(oprot)
8600 
    oprot.writeMessageEnd()
8601 
    oprot.trans.flush()
8602 
 
6019 rajveer 8603 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8604 
    args = changeJacketNumber_args()
8605 
    args.read(iprot)
8606 
    iprot.readMessageEnd()
8607 
    result = changeJacketNumber_result()
8608 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8609 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8610 
    result.write(oprot)
8611 
    oprot.writeMessageEnd()
8612 
    oprot.trans.flush()
8613 
 
8614 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8615 
    args = markOrderAsRtoInTransit_args()
8616 
    args.read(iprot)
8617 
    iprot.readMessageEnd()
8618 
    result = markOrderAsRtoInTransit_result()
8619 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8620 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8621 
    result.write(oprot)
8622 
    oprot.writeMessageEnd()
8623 
    oprot.trans.flush()
8624 
 
5593 mandeep.dh 8625 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8626 
    args = acceptOrderForItem_args()
8627 
    args.read(iprot)
8628 
    iprot.readMessageEnd()
8629 
    result = acceptOrderForItem_result()
8630 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8631 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8632 
    result.write(oprot)
8633 
    oprot.writeMessageEnd()
8634 
    oprot.trans.flush()
5553 rajveer 8635 
 
6000 mandeep.dh 8636 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8637 
    args = createRechargeOrder_args()
8638 
    args.read(iprot)
8639 
    iprot.readMessageEnd()
8640 
    result = createRechargeOrder_result()
8641 
    try:
8642 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8643 
    except TransactionServiceException, ex:
8644 
      result.ex = ex
8645 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8646 
    result.write(oprot)
8647 
    oprot.writeMessageEnd()
8648 
    oprot.trans.flush()
5593 mandeep.dh 8649 
 
6031 rajveer 8650 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8651 
    args = getRechargeOrder_args()
8652 
    args.read(iprot)
8653 
    iprot.readMessageEnd()
8654 
    result = getRechargeOrder_result()
8655 
    try:
8656 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8657 
    except TransactionServiceException, ex:
8658 
      result.ex = ex
8659 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8660 
    result.write(oprot)
8661 
    oprot.writeMessageEnd()
8662 
    oprot.trans.flush()
8663 
 
8664 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8665 
    args = getRechargeOrders_args()
8666 
    args.read(iprot)
8667 
    iprot.readMessageEnd()
8668 
    result = getRechargeOrders_result()
8669 
    result.success = self._handler.getRechargeOrders(args.userId)
8670 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8671 
    result.write(oprot)
8672 
    oprot.writeMessageEnd()
8673 
    oprot.trans.flush()
8674 
 
6000 mandeep.dh 8675 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8676 
    args = updateRechargeOrderStatus_args()
8677 
    args.read(iprot)
8678 
    iprot.readMessageEnd()
8679 
    result = updateRechargeOrderStatus_result()
8680 
    try:
6031 rajveer 8681 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8682 
    except TransactionServiceException, ex:
8683 
      result.ex = ex
8684 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8685 
    result.write(oprot)
8686 
    oprot.writeMessageEnd()
8687 
    oprot.trans.flush()
8688 
 
8689 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8690 
    args = activateRechargeTxn_args()
8691 
    args.read(iprot)
8692 
    iprot.readMessageEnd()
8693 
    result = activateRechargeTxn_result()
8694 
    try:
6031 rajveer 8695 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8696 
    except TransactionServiceException, ex:
8697 
      result.ex = ex
8698 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8699 
    result.write(oprot)
8700 
    oprot.writeMessageEnd()
8701 
    oprot.trans.flush()
8702 
 
6031 rajveer 8703 
  def process_getUserWallet(self, seqid, iprot, oprot):
8704 
    args = getUserWallet_args()
6000 mandeep.dh 8705 
    args.read(iprot)
8706 
    iprot.readMessageEnd()
6031 rajveer 8707 
    result = getUserWallet_result()
8708 
    result.success = self._handler.getUserWallet(args.userId)
8709 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8710 
    result.write(oprot)
8711 
    oprot.writeMessageEnd()
8712 
    oprot.trans.flush()
8713 
 
6031 rajveer 8714 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8715 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8716 
    args.read(iprot)
8717 
    iprot.readMessageEnd()
6031 rajveer 8718 
    result = getUserWalletHistory_result()
8719 
    result.success = self._handler.getUserWalletHistory(args.userId)
8720 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8721 
    result.write(oprot)
8722 
    oprot.writeMessageEnd()
8723 
    oprot.trans.flush()
8724 
 
6050 anupam.sin 8725 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8726 
    args = getRechargeOrdersForTransaction_args()
8727 
    args.read(iprot)
8728 
    iprot.readMessageEnd()
8729 
    result = getRechargeOrdersForTransaction_result()
8730 
    try:
8731 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8732 
    except TransactionServiceException, ex:
8733 
      result.ex = ex
8734 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8735 
    result.write(oprot)
8736 
    oprot.writeMessageEnd()
8737 
    oprot.trans.flush()
8738 
 
6048 rajveer 8739 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8740 
    args = getServiceProviders_args()
8741 
    args.read(iprot)
8742 
    iprot.readMessageEnd()
8743 
    result = getServiceProviders_result()
6206 rajveer 8744 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8745 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8746 
    result.write(oprot)
8747 
    oprot.writeMessageEnd()
8748 
    oprot.trans.flush()
6000 mandeep.dh 8749 
 
6048 rajveer 8750 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8751 
    args = getServiceProviderForDevice_args()
8752 
    args.read(iprot)
8753 
    iprot.readMessageEnd()
8754 
    result = getServiceProviderForDevice_result()
6049 rajveer 8755 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8756 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8757 
    result.write(oprot)
8758 
    oprot.writeMessageEnd()
8759 
    oprot.trans.flush()
8760 
 
6269 rajveer 8761 
  def process_validateRecharge(self, seqid, iprot, oprot):
8762 
    args = validateRecharge_args()
8763 
    args.read(iprot)
8764 
    iprot.readMessageEnd()
8765 
    result = validateRecharge_result()
6591 anupam.sin 8766 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8767 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8768 
    result.write(oprot)
8769 
    oprot.writeMessageEnd()
8770 
    oprot.trans.flush()
8771 
 
6094 rajveer 8772 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8773 
    args = getRechargeOrdersForDevice_args()
8774 
    args.read(iprot)
8775 
    iprot.readMessageEnd()
8776 
    result = getRechargeOrdersForDevice_result()
8777 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8778 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8779 
    result.write(oprot)
8780 
    oprot.writeMessageEnd()
8781 
    oprot.trans.flush()
6048 rajveer 8782 
 
6094 rajveer 8783 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8784 
    args = addAmountToWallet_args()
8785 
    args.read(iprot)
8786 
    iprot.readMessageEnd()
8787 
    result = addAmountToWallet_result()
8788 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8789 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8790 
    result.write(oprot)
8791 
    oprot.writeMessageEnd()
8792 
    oprot.trans.flush()
8793 
 
6188 rajveer 8794 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8795 
    args = getRechargeStatistics_args()
8796 
    args.read(iprot)
8797 
    iprot.readMessageEnd()
8798 
    result = getRechargeStatistics_result()
8799 
    result.success = self._handler.getRechargeStatistics()
8800 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8801 
    result.write(oprot)
8802 
    oprot.writeMessageEnd()
8803 
    oprot.trans.flush()
8804 
 
6154 rajveer 8805 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8806 
    args = getRechargeOrdersForStatus_args()
8807 
    args.read(iprot)
8808 
    iprot.readMessageEnd()
8809 
    result = getRechargeOrdersForStatus_result()
8810 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8811 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8812 
    result.write(oprot)
8813 
    oprot.writeMessageEnd()
8814 
    oprot.trans.flush()
6094 rajveer 8815 
 
6159 rajveer 8816 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8817 
    args = getPlansForOperator_args()
8818 
    args.read(iprot)
8819 
    iprot.readMessageEnd()
8820 
    result = getPlansForOperator_result()
8821 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8822 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8823 
    result.write(oprot)
8824 
    oprot.writeMessageEnd()
8825 
    oprot.trans.flush()
6154 rajveer 8826 
 
6289 anupam.sin 8827 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8828 
    args = getRechargeDenominations_args()
8829 
    args.read(iprot)
8830 
    iprot.readMessageEnd()
8831 
    result = getRechargeDenominations_result()
8832 
    try:
6307 anupam.sin 8833 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8834 
    except TransactionServiceException, ex:
8835 
      result.ex = ex
8836 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8837 
    result.write(oprot)
8838 
    oprot.writeMessageEnd()
8839 
    oprot.trans.flush()
6159 rajveer 8840 
 
6371 rajveer 8841 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8842 
    args = updateAvailabilityStatus_args()
8843 
    args.read(iprot)
8844 
    iprot.readMessageEnd()
8845 
    result = updateAvailabilityStatus_result()
8846 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8847 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8848 
    result.write(oprot)
8849 
    oprot.writeMessageEnd()
8850 
    oprot.trans.flush()
6289 anupam.sin 8851 
 
6389 rajveer 8852 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8853 
    args = getAvailableEmiSchemes_args()
8854 
    args.read(iprot)
8855 
    iprot.readMessageEnd()
8856 
    result = getAvailableEmiSchemes_result()
8857 
    result.success = self._handler.getAvailableEmiSchemes()
8858 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8859 
    result.write(oprot)
8860 
    oprot.writeMessageEnd()
8861 
    oprot.trans.flush()
6371 rajveer 8862 
 
6389 rajveer 8863 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8864 
    args = getMiscCharges_args()
8865 
    args.read(iprot)
8866 
    iprot.readMessageEnd()
8867 
    result = getMiscCharges_result()
8868 
    result.success = self._handler.getMiscCharges(args.transactionId)
8869 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8870 
    result.write(oprot)
8871 
    oprot.writeMessageEnd()
8872 
    oprot.trans.flush()
8873 
 
6507 anupam.sin 8874 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8875 
    args = refundRechargeOrder_args()
8876 
    args.read(iprot)
8877 
    iprot.readMessageEnd()
8878 
    result = refundRechargeOrder_result()
8879 
    try:
8880 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8881 
    except TransactionServiceException, ex:
8882 
      result.ex = ex
8883 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8884 
    result.write(oprot)
8885 
    oprot.writeMessageEnd()
8886 
    oprot.trans.flush()
6389 rajveer 8887 
 
6821 amar.kumar 8888 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
8889 
    args = getPhysicalOrders_args()
8890 
    args.read(iprot)
8891 
    iprot.readMessageEnd()
8892 
    result = getPhysicalOrders_result()
8893 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
8894 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
8895 
    result.write(oprot)
8896 
    oprot.writeMessageEnd()
8897 
    oprot.trans.flush()
6507 anupam.sin 8898 
 
6906 rajveer 8899 
  def process_getDocument(self, seqid, iprot, oprot):
8900 
    args = getDocument_args()
8901 
    args.read(iprot)
8902 
    iprot.readMessageEnd()
8903 
    result = getDocument_result()
8904 
    result.success = self._handler.getDocument(args.docType, args.docSource)
8905 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
8906 
    result.write(oprot)
8907 
    oprot.writeMessageEnd()
8908 
    oprot.trans.flush()
6821 amar.kumar 8909 
 
6985 anupam.sin 8910 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
8911 
    args = changeShippingAddress_args()
8912 
    args.read(iprot)
8913 
    iprot.readMessageEnd()
8914 
    result = changeShippingAddress_result()
8915 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
8916 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
8917 
    result.write(oprot)
8918 
    oprot.writeMessageEnd()
8919 
    oprot.trans.flush()
6906 rajveer 8920 
 
6988 rajveer 8921 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
8922 
    args = retrieveInvoice_args()
8923 
    args.read(iprot)
8924 
    iprot.readMessageEnd()
8925 
    result = retrieveInvoice_result()
8926 
    result.success = self._handler.retrieveInvoice(args.orderId)
8927 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
8928 
    result.write(oprot)
8929 
    oprot.writeMessageEnd()
8930 
    oprot.trans.flush()
6985 anupam.sin 8931 
 
7026 rajveer 8932 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
8933 
    args = receiveUpdatesForRedExpress_args()
8934 
    args.read(iprot)
8935 
    iprot.readMessageEnd()
8936 
    result = receiveUpdatesForRedExpress_result()
8937 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
8938 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
8939 
    result.write(oprot)
8940 
    oprot.writeMessageEnd()
8941 
    oprot.trans.flush()
6988 rajveer 8942 
 
7073 anupam.sin 8943 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
8944 
    args = createRechargeTransaction_args()
8945 
    args.read(iprot)
8946 
    iprot.readMessageEnd()
8947 
    result = createRechargeTransaction_result()
8948 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
8949 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
8950 
    result.write(oprot)
8951 
    oprot.writeMessageEnd()
8952 
    oprot.trans.flush()
7026 rajveer 8953 
 
7073 anupam.sin 8954 
 
94 ashish 8955 
# HELPER FUNCTIONS AND STRUCTURES
8956 
 
8957 
class createTransaction_args:
8958 
  """
8959 
  Attributes:
8960 
   - transaction
8961 
  """
8962 
 
8963 
  thrift_spec = (
8964 
    None, # 0
8965 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8966 
  )
8967 
 
8968 
  def __init__(self, transaction=None,):
8969 
    self.transaction = transaction
8970 
 
8971 
  def read(self, iprot):
8972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8974 
      return
8975 
    iprot.readStructBegin()
8976 
    while True:
8977 
      (fname, ftype, fid) = iprot.readFieldBegin()
8978 
      if ftype == TType.STOP:
8979 
        break
8980 
      if fid == 1:
8981 
        if ftype == TType.STRUCT:
8982 
          self.transaction = Transaction()
8983 
          self.transaction.read(iprot)
8984 
        else:
8985 
          iprot.skip(ftype)
8986 
      else:
8987 
        iprot.skip(ftype)
8988 
      iprot.readFieldEnd()
8989 
    iprot.readStructEnd()
8990 
 
8991 
  def write(self, oprot):
8992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8994 
      return
8995 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8996 
    if self.transaction is not None:
94 ashish 8997 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8998 
      self.transaction.write(oprot)
8999 
      oprot.writeFieldEnd()
9000 
    oprot.writeFieldStop()
9001 
    oprot.writeStructEnd()
9002 
 
3431 rajveer 9003 
  def validate(self):
9004 
    return
9005 
 
9006 
 
94 ashish 9007 
  def __repr__(self):
9008 
    L = ['%s=%r' % (key, value)
9009 
      for key, value in self.__dict__.iteritems()]
9010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9011 
 
9012 
  def __eq__(self, other):
9013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9014 
 
9015 
  def __ne__(self, other):
9016 
    return not (self == other)
9017 
 
9018 
class createTransaction_result:
9019 
  """
9020 
  Attributes:
132 ashish 9021 
   - success
94 ashish 9022 
   - ex
9023 
  """
9024 
 
9025 
  thrift_spec = (
132 ashish 9026 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9028 
  )
9029 
 
132 ashish 9030 
  def __init__(self, success=None, ex=None,):
9031 
    self.success = success
94 ashish 9032 
    self.ex = ex
9033 
 
9034 
  def read(self, iprot):
9035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9037 
      return
9038 
    iprot.readStructBegin()
9039 
    while True:
9040 
      (fname, ftype, fid) = iprot.readFieldBegin()
9041 
      if ftype == TType.STOP:
9042 
        break
132 ashish 9043 
      if fid == 0:
9044 
        if ftype == TType.I64:
9045 
          self.success = iprot.readI64();
9046 
        else:
9047 
          iprot.skip(ftype)
9048 
      elif fid == 1:
94 ashish 9049 
        if ftype == TType.STRUCT:
9050 
          self.ex = TransactionServiceException()
9051 
          self.ex.read(iprot)
9052 
        else:
9053 
          iprot.skip(ftype)
9054 
      else:
9055 
        iprot.skip(ftype)
9056 
      iprot.readFieldEnd()
9057 
    iprot.readStructEnd()
9058 
 
9059 
  def write(self, oprot):
9060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9062 
      return
9063 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9064 
    if self.success is not None:
132 ashish 9065 
      oprot.writeFieldBegin('success', TType.I64, 0)
9066 
      oprot.writeI64(self.success)
9067 
      oprot.writeFieldEnd()
3431 rajveer 9068 
    if self.ex is not None:
94 ashish 9069 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9070 
      self.ex.write(oprot)
9071 
      oprot.writeFieldEnd()
9072 
    oprot.writeFieldStop()
9073 
    oprot.writeStructEnd()
9074 
 
3431 rajveer 9075 
  def validate(self):
9076 
    return
9077 
 
9078 
 
94 ashish 9079 
  def __repr__(self):
9080 
    L = ['%s=%r' % (key, value)
9081 
      for key, value in self.__dict__.iteritems()]
9082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9083 
 
9084 
  def __eq__(self, other):
9085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9086 
 
9087 
  def __ne__(self, other):
9088 
    return not (self == other)
9089 
 
9090 
class getTransaction_args:
9091 
  """
9092 
  Attributes:
9093 
   - id
9094 
  """
9095 
 
9096 
  thrift_spec = (
9097 
    None, # 0
9098 
    (1, TType.I64, 'id', None, None, ), # 1
9099 
  )
9100 
 
9101 
  def __init__(self, id=None,):
9102 
    self.id = id
9103 
 
9104 
  def read(self, iprot):
9105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9107 
      return
9108 
    iprot.readStructBegin()
9109 
    while True:
9110 
      (fname, ftype, fid) = iprot.readFieldBegin()
9111 
      if ftype == TType.STOP:
9112 
        break
9113 
      if fid == 1:
9114 
        if ftype == TType.I64:
9115 
          self.id = iprot.readI64();
9116 
        else:
9117 
          iprot.skip(ftype)
9118 
      else:
9119 
        iprot.skip(ftype)
9120 
      iprot.readFieldEnd()
9121 
    iprot.readStructEnd()
9122 
 
9123 
  def write(self, oprot):
9124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9126 
      return
9127 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9128 
    if self.id is not None:
94 ashish 9129 
      oprot.writeFieldBegin('id', TType.I64, 1)
9130 
      oprot.writeI64(self.id)
9131 
      oprot.writeFieldEnd()
9132 
    oprot.writeFieldStop()
9133 
    oprot.writeStructEnd()
9134 
 
3431 rajveer 9135 
  def validate(self):
9136 
    return
9137 
 
9138 
 
94 ashish 9139 
  def __repr__(self):
9140 
    L = ['%s=%r' % (key, value)
9141 
      for key, value in self.__dict__.iteritems()]
9142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9143 
 
9144 
  def __eq__(self, other):
9145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9146 
 
9147 
  def __ne__(self, other):
9148 
    return not (self == other)
9149 
 
9150 
class getTransaction_result:
9151 
  """
9152 
  Attributes:
9153 
   - success
9154 
   - ex
9155 
  """
9156 
 
9157 
  thrift_spec = (
9158 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9159 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9160 
  )
9161 
 
9162 
  def __init__(self, success=None, ex=None,):
9163 
    self.success = success
9164 
    self.ex = ex
9165 
 
9166 
  def read(self, iprot):
9167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9169 
      return
9170 
    iprot.readStructBegin()
9171 
    while True:
9172 
      (fname, ftype, fid) = iprot.readFieldBegin()
9173 
      if ftype == TType.STOP:
9174 
        break
9175 
      if fid == 0:
9176 
        if ftype == TType.STRUCT:
9177 
          self.success = Transaction()
9178 
          self.success.read(iprot)
9179 
        else:
9180 
          iprot.skip(ftype)
9181 
      elif fid == 1:
9182 
        if ftype == TType.STRUCT:
9183 
          self.ex = TransactionServiceException()
9184 
          self.ex.read(iprot)
9185 
        else:
9186 
          iprot.skip(ftype)
9187 
      else:
9188 
        iprot.skip(ftype)
9189 
      iprot.readFieldEnd()
9190 
    iprot.readStructEnd()
9191 
 
9192 
  def write(self, oprot):
9193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9195 
      return
9196 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9197 
    if self.success is not None:
94 ashish 9198 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9199 
      self.success.write(oprot)
9200 
      oprot.writeFieldEnd()
3431 rajveer 9201 
    if self.ex is not None:
94 ashish 9202 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9203 
      self.ex.write(oprot)
9204 
      oprot.writeFieldEnd()
9205 
    oprot.writeFieldStop()
9206 
    oprot.writeStructEnd()
9207 
 
3431 rajveer 9208 
  def validate(self):
9209 
    return
9210 
 
9211 
 
94 ashish 9212 
  def __repr__(self):
9213 
    L = ['%s=%r' % (key, value)
9214 
      for key, value in self.__dict__.iteritems()]
9215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9216 
 
9217 
  def __eq__(self, other):
9218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9219 
 
9220 
  def __ne__(self, other):
9221 
    return not (self == other)
9222 
 
9223 
class getTransactionsForCustomer_args:
9224 
  """
9225 
  Attributes:
9226 
   - customerId
9227 
   - from_date
9228 
   - to_date
9229 
   - status
9230 
  """
9231 
 
9232 
  thrift_spec = (
9233 
    None, # 0
9234 
    (1, TType.I64, 'customerId', None, None, ), # 1
9235 
    (2, TType.I64, 'from_date', None, None, ), # 2
9236 
    (3, TType.I64, 'to_date', None, None, ), # 3
9237 
    (4, TType.I32, 'status', None, None, ), # 4
9238 
  )
9239 
 
9240 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9241 
    self.customerId = customerId
9242 
    self.from_date = from_date
9243 
    self.to_date = to_date
9244 
    self.status = status
9245 
 
9246 
  def read(self, iprot):
9247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9249 
      return
9250 
    iprot.readStructBegin()
9251 
    while True:
9252 
      (fname, ftype, fid) = iprot.readFieldBegin()
9253 
      if ftype == TType.STOP:
9254 
        break
9255 
      if fid == 1:
9256 
        if ftype == TType.I64:
9257 
          self.customerId = iprot.readI64();
9258 
        else:
9259 
          iprot.skip(ftype)
9260 
      elif fid == 2:
9261 
        if ftype == TType.I64:
9262 
          self.from_date = iprot.readI64();
9263 
        else:
9264 
          iprot.skip(ftype)
9265 
      elif fid == 3:
9266 
        if ftype == TType.I64:
9267 
          self.to_date = iprot.readI64();
9268 
        else:
9269 
          iprot.skip(ftype)
9270 
      elif fid == 4:
9271 
        if ftype == TType.I32:
9272 
          self.status = iprot.readI32();
9273 
        else:
9274 
          iprot.skip(ftype)
9275 
      else:
9276 
        iprot.skip(ftype)
9277 
      iprot.readFieldEnd()
9278 
    iprot.readStructEnd()
9279 
 
9280 
  def write(self, oprot):
9281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9283 
      return
9284 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9285 
    if self.customerId is not None:
94 ashish 9286 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9287 
      oprot.writeI64(self.customerId)
9288 
      oprot.writeFieldEnd()
3431 rajveer 9289 
    if self.from_date is not None:
94 ashish 9290 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9291 
      oprot.writeI64(self.from_date)
9292 
      oprot.writeFieldEnd()
3431 rajveer 9293 
    if self.to_date is not None:
94 ashish 9294 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9295 
      oprot.writeI64(self.to_date)
9296 
      oprot.writeFieldEnd()
3431 rajveer 9297 
    if self.status is not None:
94 ashish 9298 
      oprot.writeFieldBegin('status', TType.I32, 4)
9299 
      oprot.writeI32(self.status)
9300 
      oprot.writeFieldEnd()
9301 
    oprot.writeFieldStop()
9302 
    oprot.writeStructEnd()
9303 
 
3431 rajveer 9304 
  def validate(self):
9305 
    return
9306 
 
9307 
 
94 ashish 9308 
  def __repr__(self):
9309 
    L = ['%s=%r' % (key, value)
9310 
      for key, value in self.__dict__.iteritems()]
9311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9312 
 
9313 
  def __eq__(self, other):
9314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9315 
 
9316 
  def __ne__(self, other):
9317 
    return not (self == other)
9318 
 
9319 
class getTransactionsForCustomer_result:
9320 
  """
9321 
  Attributes:
9322 
   - success
9323 
   - ex
9324 
  """
9325 
 
9326 
  thrift_spec = (
9327 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9328 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9329 
  )
9330 
 
9331 
  def __init__(self, success=None, ex=None,):
9332 
    self.success = success
9333 
    self.ex = ex
9334 
 
9335 
  def read(self, iprot):
9336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9338 
      return
9339 
    iprot.readStructBegin()
9340 
    while True:
9341 
      (fname, ftype, fid) = iprot.readFieldBegin()
9342 
      if ftype == TType.STOP:
9343 
        break
9344 
      if fid == 0:
9345 
        if ftype == TType.LIST:
9346 
          self.success = []
6188 rajveer 9347 
          (_etype109, _size106) = iprot.readListBegin()
9348 
          for _i110 in xrange(_size106):
9349 
            _elem111 = Transaction()
9350 
            _elem111.read(iprot)
9351 
            self.success.append(_elem111)
94 ashish 9352 
          iprot.readListEnd()
9353 
        else:
9354 
          iprot.skip(ftype)
9355 
      elif fid == 1:
9356 
        if ftype == TType.STRUCT:
9357 
          self.ex = TransactionServiceException()
9358 
          self.ex.read(iprot)
9359 
        else:
9360 
          iprot.skip(ftype)
9361 
      else:
9362 
        iprot.skip(ftype)
9363 
      iprot.readFieldEnd()
9364 
    iprot.readStructEnd()
9365 
 
9366 
  def write(self, oprot):
9367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9369 
      return
9370 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9371 
    if self.success is not None:
94 ashish 9372 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9373 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9374 
      for iter112 in self.success:
9375 
        iter112.write(oprot)
94 ashish 9376 
      oprot.writeListEnd()
9377 
      oprot.writeFieldEnd()
3431 rajveer 9378 
    if self.ex is not None:
94 ashish 9379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9380 
      self.ex.write(oprot)
9381 
      oprot.writeFieldEnd()
9382 
    oprot.writeFieldStop()
9383 
    oprot.writeStructEnd()
9384 
 
3431 rajveer 9385 
  def validate(self):
9386 
    return
9387 
 
9388 
 
94 ashish 9389 
  def __repr__(self):
9390 
    L = ['%s=%r' % (key, value)
9391 
      for key, value in self.__dict__.iteritems()]
9392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9393 
 
9394 
  def __eq__(self, other):
9395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9396 
 
9397 
  def __ne__(self, other):
9398 
    return not (self == other)
9399 
 
132 ashish 9400 
class getTransactionsForShoppingCartId_args:
9401 
  """
9402 
  Attributes:
9403 
   - shoppingCartId
9404 
  """
9405 
 
9406 
  thrift_spec = (
9407 
    None, # 0
9408 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9409 
  )
9410 
 
9411 
  def __init__(self, shoppingCartId=None,):
9412 
    self.shoppingCartId = shoppingCartId
9413 
 
9414 
  def read(self, iprot):
9415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9417 
      return
9418 
    iprot.readStructBegin()
9419 
    while True:
9420 
      (fname, ftype, fid) = iprot.readFieldBegin()
9421 
      if ftype == TType.STOP:
9422 
        break
9423 
      if fid == 1:
9424 
        if ftype == TType.I64:
9425 
          self.shoppingCartId = iprot.readI64();
9426 
        else:
9427 
          iprot.skip(ftype)
9428 
      else:
9429 
        iprot.skip(ftype)
9430 
      iprot.readFieldEnd()
9431 
    iprot.readStructEnd()
9432 
 
9433 
  def write(self, oprot):
9434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9436 
      return
9437 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9438 
    if self.shoppingCartId is not None:
132 ashish 9439 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9440 
      oprot.writeI64(self.shoppingCartId)
9441 
      oprot.writeFieldEnd()
9442 
    oprot.writeFieldStop()
9443 
    oprot.writeStructEnd()
9444 
 
3431 rajveer 9445 
  def validate(self):
9446 
    return
9447 
 
9448 
 
132 ashish 9449 
  def __repr__(self):
9450 
    L = ['%s=%r' % (key, value)
9451 
      for key, value in self.__dict__.iteritems()]
9452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9453 
 
9454 
  def __eq__(self, other):
9455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9456 
 
9457 
  def __ne__(self, other):
9458 
    return not (self == other)
9459 
 
9460 
class getTransactionsForShoppingCartId_result:
9461 
  """
9462 
  Attributes:
9463 
   - success
9464 
   - ex
9465 
  """
9466 
 
9467 
  thrift_spec = (
9468 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9469 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9470 
  )
9471 
 
9472 
  def __init__(self, success=None, ex=None,):
9473 
    self.success = success
9474 
    self.ex = ex
9475 
 
9476 
  def read(self, iprot):
9477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9479 
      return
9480 
    iprot.readStructBegin()
9481 
    while True:
9482 
      (fname, ftype, fid) = iprot.readFieldBegin()
9483 
      if ftype == TType.STOP:
9484 
        break
9485 
      if fid == 0:
9486 
        if ftype == TType.LIST:
9487 
          self.success = []
6188 rajveer 9488 
          (_etype116, _size113) = iprot.readListBegin()
9489 
          for _i117 in xrange(_size113):
9490 
            _elem118 = Transaction()
9491 
            _elem118.read(iprot)
9492 
            self.success.append(_elem118)
132 ashish 9493 
          iprot.readListEnd()
9494 
        else:
9495 
          iprot.skip(ftype)
9496 
      elif fid == 1:
9497 
        if ftype == TType.STRUCT:
9498 
          self.ex = TransactionServiceException()
9499 
          self.ex.read(iprot)
9500 
        else:
9501 
          iprot.skip(ftype)
9502 
      else:
9503 
        iprot.skip(ftype)
9504 
      iprot.readFieldEnd()
9505 
    iprot.readStructEnd()
9506 
 
9507 
  def write(self, oprot):
9508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9510 
      return
9511 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9512 
    if self.success is not None:
132 ashish 9513 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9514 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9515 
      for iter119 in self.success:
9516 
        iter119.write(oprot)
132 ashish 9517 
      oprot.writeListEnd()
9518 
      oprot.writeFieldEnd()
3431 rajveer 9519 
    if self.ex is not None:
132 ashish 9520 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9521 
      self.ex.write(oprot)
9522 
      oprot.writeFieldEnd()
9523 
    oprot.writeFieldStop()
9524 
    oprot.writeStructEnd()
9525 
 
3431 rajveer 9526 
  def validate(self):
9527 
    return
9528 
 
9529 
 
132 ashish 9530 
  def __repr__(self):
9531 
    L = ['%s=%r' % (key, value)
9532 
      for key, value in self.__dict__.iteritems()]
9533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9534 
 
9535 
  def __eq__(self, other):
9536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9537 
 
9538 
  def __ne__(self, other):
9539 
    return not (self == other)
9540 
 
94 ashish 9541 
class getTransactionStatus_args:
9542 
  """
9543 
  Attributes:
9544 
   - transactionId
9545 
  """
9546 
 
9547 
  thrift_spec = (
9548 
    None, # 0
9549 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9550 
  )
9551 
 
9552 
  def __init__(self, transactionId=None,):
9553 
    self.transactionId = transactionId
9554 
 
9555 
  def read(self, iprot):
9556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9558 
      return
9559 
    iprot.readStructBegin()
9560 
    while True:
9561 
      (fname, ftype, fid) = iprot.readFieldBegin()
9562 
      if ftype == TType.STOP:
9563 
        break
9564 
      if fid == 1:
9565 
        if ftype == TType.I64:
9566 
          self.transactionId = iprot.readI64();
9567 
        else:
9568 
          iprot.skip(ftype)
9569 
      else:
9570 
        iprot.skip(ftype)
9571 
      iprot.readFieldEnd()
9572 
    iprot.readStructEnd()
9573 
 
9574 
  def write(self, oprot):
9575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9577 
      return
9578 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9579 
    if self.transactionId is not None:
94 ashish 9580 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9581 
      oprot.writeI64(self.transactionId)
9582 
      oprot.writeFieldEnd()
9583 
    oprot.writeFieldStop()
9584 
    oprot.writeStructEnd()
9585 
 
3431 rajveer 9586 
  def validate(self):
9587 
    return
9588 
 
9589 
 
94 ashish 9590 
  def __repr__(self):
9591 
    L = ['%s=%r' % (key, value)
9592 
      for key, value in self.__dict__.iteritems()]
9593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9594 
 
9595 
  def __eq__(self, other):
9596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9597 
 
9598 
  def __ne__(self, other):
9599 
    return not (self == other)
9600 
 
9601 
class getTransactionStatus_result:
9602 
  """
9603 
  Attributes:
9604 
   - success
9605 
   - ex
9606 
  """
9607 
 
9608 
  thrift_spec = (
9609 
    (0, TType.I32, 'success', None, None, ), # 0
9610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9611 
  )
9612 
 
9613 
  def __init__(self, success=None, ex=None,):
9614 
    self.success = success
9615 
    self.ex = ex
9616 
 
9617 
  def read(self, iprot):
9618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9620 
      return
9621 
    iprot.readStructBegin()
9622 
    while True:
9623 
      (fname, ftype, fid) = iprot.readFieldBegin()
9624 
      if ftype == TType.STOP:
9625 
        break
9626 
      if fid == 0:
9627 
        if ftype == TType.I32:
9628 
          self.success = iprot.readI32();
9629 
        else:
9630 
          iprot.skip(ftype)
9631 
      elif fid == 1:
9632 
        if ftype == TType.STRUCT:
9633 
          self.ex = TransactionServiceException()
9634 
          self.ex.read(iprot)
9635 
        else:
9636 
          iprot.skip(ftype)
9637 
      else:
9638 
        iprot.skip(ftype)
9639 
      iprot.readFieldEnd()
9640 
    iprot.readStructEnd()
9641 
 
9642 
  def write(self, oprot):
9643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9645 
      return
9646 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9647 
    if self.success is not None:
94 ashish 9648 
      oprot.writeFieldBegin('success', TType.I32, 0)
9649 
      oprot.writeI32(self.success)
9650 
      oprot.writeFieldEnd()
3431 rajveer 9651 
    if self.ex is not None:
94 ashish 9652 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9653 
      self.ex.write(oprot)
9654 
      oprot.writeFieldEnd()
9655 
    oprot.writeFieldStop()
9656 
    oprot.writeStructEnd()
9657 
 
3431 rajveer 9658 
  def validate(self):
9659 
    return
9660 
 
9661 
 
94 ashish 9662 
  def __repr__(self):
9663 
    L = ['%s=%r' % (key, value)
9664 
      for key, value in self.__dict__.iteritems()]
9665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9666 
 
9667 
  def __eq__(self, other):
9668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9669 
 
9670 
  def __ne__(self, other):
9671 
    return not (self == other)
9672 
 
9673 
class changeTransactionStatus_args:
9674 
  """
9675 
  Attributes:
9676 
   - transactionId
9677 
   - status
9678 
   - description
5527 anupam.sin 9679 
   - pickUp
9680 
   - orderType
94 ashish 9681 
  """
9682 
 
9683 
  thrift_spec = (
9684 
    None, # 0
9685 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9686 
    (2, TType.I32, 'status', None, None, ), # 2
9687 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9688 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9689 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9690 
  )
9691 
 
5527 anupam.sin 9692 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9693 
    self.transactionId = transactionId
9694 
    self.status = status
9695 
    self.description = description
5527 anupam.sin 9696 
    self.pickUp = pickUp
9697 
    self.orderType = orderType
94 ashish 9698 
 
9699 
  def read(self, iprot):
9700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9702 
      return
9703 
    iprot.readStructBegin()
9704 
    while True:
9705 
      (fname, ftype, fid) = iprot.readFieldBegin()
9706 
      if ftype == TType.STOP:
9707 
        break
9708 
      if fid == 1:
9709 
        if ftype == TType.I64:
9710 
          self.transactionId = iprot.readI64();
9711 
        else:
9712 
          iprot.skip(ftype)
9713 
      elif fid == 2:
9714 
        if ftype == TType.I32:
9715 
          self.status = iprot.readI32();
9716 
        else:
9717 
          iprot.skip(ftype)
9718 
      elif fid == 3:
9719 
        if ftype == TType.STRING:
9720 
          self.description = iprot.readString();
9721 
        else:
9722 
          iprot.skip(ftype)
5387 rajveer 9723 
      elif fid == 4:
5527 anupam.sin 9724 
        if ftype == TType.I64:
9725 
          self.pickUp = iprot.readI64();
5387 rajveer 9726 
        else:
9727 
          iprot.skip(ftype)
5527 anupam.sin 9728 
      elif fid == 5:
9729 
        if ftype == TType.I32:
9730 
          self.orderType = iprot.readI32();
9731 
        else:
9732 
          iprot.skip(ftype)
94 ashish 9733 
      else:
9734 
        iprot.skip(ftype)
9735 
      iprot.readFieldEnd()
9736 
    iprot.readStructEnd()
9737 
 
9738 
  def write(self, oprot):
9739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9741 
      return
9742 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9743 
    if self.transactionId is not None:
94 ashish 9744 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9745 
      oprot.writeI64(self.transactionId)
9746 
      oprot.writeFieldEnd()
3431 rajveer 9747 
    if self.status is not None:
94 ashish 9748 
      oprot.writeFieldBegin('status', TType.I32, 2)
9749 
      oprot.writeI32(self.status)
9750 
      oprot.writeFieldEnd()
3431 rajveer 9751 
    if self.description is not None:
94 ashish 9752 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9753 
      oprot.writeString(self.description)
9754 
      oprot.writeFieldEnd()
5527 anupam.sin 9755 
    if self.pickUp is not None:
9756 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9757 
      oprot.writeI64(self.pickUp)
5387 rajveer 9758 
      oprot.writeFieldEnd()
5527 anupam.sin 9759 
    if self.orderType is not None:
9760 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9761 
      oprot.writeI32(self.orderType)
9762 
      oprot.writeFieldEnd()
94 ashish 9763 
    oprot.writeFieldStop()
9764 
    oprot.writeStructEnd()
9765 
 
3431 rajveer 9766 
  def validate(self):
9767 
    return
9768 
 
9769 
 
94 ashish 9770 
  def __repr__(self):
9771 
    L = ['%s=%r' % (key, value)
9772 
      for key, value in self.__dict__.iteritems()]
9773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9774 
 
9775 
  def __eq__(self, other):
9776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9777 
 
9778 
  def __ne__(self, other):
9779 
    return not (self == other)
9780 
 
9781 
class changeTransactionStatus_result:
9782 
  """
9783 
  Attributes:
9784 
   - success
9785 
   - ex
9786 
  """
9787 
 
9788 
  thrift_spec = (
9789 
    (0, TType.BOOL, 'success', None, None, ), # 0
9790 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9791 
  )
9792 
 
9793 
  def __init__(self, success=None, ex=None,):
9794 
    self.success = success
9795 
    self.ex = ex
9796 
 
9797 
  def read(self, iprot):
9798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9800 
      return
9801 
    iprot.readStructBegin()
9802 
    while True:
9803 
      (fname, ftype, fid) = iprot.readFieldBegin()
9804 
      if ftype == TType.STOP:
9805 
        break
9806 
      if fid == 0:
9807 
        if ftype == TType.BOOL:
9808 
          self.success = iprot.readBool();
9809 
        else:
9810 
          iprot.skip(ftype)
9811 
      elif fid == 1:
9812 
        if ftype == TType.STRUCT:
9813 
          self.ex = TransactionServiceException()
9814 
          self.ex.read(iprot)
9815 
        else:
9816 
          iprot.skip(ftype)
9817 
      else:
9818 
        iprot.skip(ftype)
9819 
      iprot.readFieldEnd()
9820 
    iprot.readStructEnd()
9821 
 
9822 
  def write(self, oprot):
9823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9825 
      return
9826 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9827 
    if self.success is not None:
94 ashish 9828 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9829 
      oprot.writeBool(self.success)
9830 
      oprot.writeFieldEnd()
3431 rajveer 9831 
    if self.ex is not None:
94 ashish 9832 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9833 
      self.ex.write(oprot)
9834 
      oprot.writeFieldEnd()
9835 
    oprot.writeFieldStop()
9836 
    oprot.writeStructEnd()
9837 
 
3431 rajveer 9838 
  def validate(self):
9839 
    return
9840 
 
9841 
 
94 ashish 9842 
  def __repr__(self):
9843 
    L = ['%s=%r' % (key, value)
9844 
      for key, value in self.__dict__.iteritems()]
9845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9846 
 
9847 
  def __eq__(self, other):
9848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9849 
 
9850 
  def __ne__(self, other):
9851 
    return not (self == other)
9852 
 
1398 varun.gupt 9853 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9854 
  """
9855 
  Attributes:
9856 
   - transactionId
9857 
  """
9858 
 
9859 
  thrift_spec = (
9860 
    None, # 0
9861 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9862 
  )
9863 
 
9864 
  def __init__(self, transactionId=None,):
9865 
    self.transactionId = transactionId
9866 
 
9867 
  def read(self, iprot):
9868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9870 
      return
9871 
    iprot.readStructBegin()
9872 
    while True:
9873 
      (fname, ftype, fid) = iprot.readFieldBegin()
9874 
      if ftype == TType.STOP:
9875 
        break
9876 
      if fid == 1:
9877 
        if ftype == TType.I64:
9878 
          self.transactionId = iprot.readI64();
9879 
        else:
9880 
          iprot.skip(ftype)
9881 
      else:
9882 
        iprot.skip(ftype)
9883 
      iprot.readFieldEnd()
9884 
    iprot.readStructEnd()
9885 
 
9886 
  def write(self, oprot):
9887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9889 
      return
1398 varun.gupt 9890 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9891 
    if self.transactionId is not None:
1382 varun.gupt 9892 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9893 
      oprot.writeI64(self.transactionId)
9894 
      oprot.writeFieldEnd()
9895 
    oprot.writeFieldStop()
9896 
    oprot.writeStructEnd()
9897 
 
3431 rajveer 9898 
  def validate(self):
9899 
    return
9900 
 
9901 
 
1382 varun.gupt 9902 
  def __repr__(self):
9903 
    L = ['%s=%r' % (key, value)
9904 
      for key, value in self.__dict__.iteritems()]
9905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9906 
 
9907 
  def __eq__(self, other):
9908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9909 
 
9910 
  def __ne__(self, other):
9911 
    return not (self == other)
9912 
 
1398 varun.gupt 9913 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9914 
  """
9915 
  Attributes:
9916 
   - success
9917 
   - ex
9918 
  """
9919 
 
9920 
  thrift_spec = (
9921 
    (0, TType.BOOL, 'success', None, None, ), # 0
9922 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9923 
  )
9924 
 
9925 
  def __init__(self, success=None, ex=None,):
9926 
    self.success = success
9927 
    self.ex = ex
9928 
 
9929 
  def read(self, iprot):
9930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9932 
      return
9933 
    iprot.readStructBegin()
9934 
    while True:
9935 
      (fname, ftype, fid) = iprot.readFieldBegin()
9936 
      if ftype == TType.STOP:
9937 
        break
9938 
      if fid == 0:
9939 
        if ftype == TType.BOOL:
9940 
          self.success = iprot.readBool();
9941 
        else:
9942 
          iprot.skip(ftype)
9943 
      elif fid == 1:
9944 
        if ftype == TType.STRUCT:
9945 
          self.ex = TransactionServiceException()
9946 
          self.ex.read(iprot)
9947 
        else:
9948 
          iprot.skip(ftype)
9949 
      else:
9950 
        iprot.skip(ftype)
9951 
      iprot.readFieldEnd()
9952 
    iprot.readStructEnd()
9953 
 
9954 
  def write(self, oprot):
9955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9957 
      return
1398 varun.gupt 9958 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9959 
    if self.success is not None:
1382 varun.gupt 9960 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9961 
      oprot.writeBool(self.success)
9962 
      oprot.writeFieldEnd()
3431 rajveer 9963 
    if self.ex is not None:
1382 varun.gupt 9964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9965 
      self.ex.write(oprot)
9966 
      oprot.writeFieldEnd()
9967 
    oprot.writeFieldStop()
9968 
    oprot.writeStructEnd()
9969 
 
3431 rajveer 9970 
  def validate(self):
9971 
    return
9972 
 
9973 
 
1382 varun.gupt 9974 
  def __repr__(self):
9975 
    L = ['%s=%r' % (key, value)
9976 
      for key, value in self.__dict__.iteritems()]
9977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9978 
 
9979 
  def __eq__(self, other):
9980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9981 
 
9982 
  def __ne__(self, other):
9983 
    return not (self == other)
9984 
 
483 rajveer 9985 
class getAllOrders_args:
94 ashish 9986 
  """
9987 
  Attributes:
4801 anupam.sin 9988 
   - statuses
483 rajveer 9989 
   - from_date
9990 
   - to_date
9991 
   - warehouse_id
94 ashish 9992 
  """
9993 
 
9994 
  thrift_spec = (
9995 
    None, # 0
4801 anupam.sin 9996 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9997 
    (2, TType.I64, 'from_date', None, None, ), # 2
9998 
    (3, TType.I64, 'to_date', None, None, ), # 3
9999 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10000 
  )
10001 
 
4801 anupam.sin 10002 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10003 
    self.statuses = statuses
483 rajveer 10004 
    self.from_date = from_date
10005 
    self.to_date = to_date
10006 
    self.warehouse_id = warehouse_id
94 ashish 10007 
 
10008 
  def read(self, iprot):
10009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10011 
      return
10012 
    iprot.readStructBegin()
10013 
    while True:
10014 
      (fname, ftype, fid) = iprot.readFieldBegin()
10015 
      if ftype == TType.STOP:
10016 
        break
10017 
      if fid == 1:
4801 anupam.sin 10018 
        if ftype == TType.LIST:
10019 
          self.statuses = []
6188 rajveer 10020 
          (_etype123, _size120) = iprot.readListBegin()
10021 
          for _i124 in xrange(_size120):
10022 
            _elem125 = iprot.readI32();
10023 
            self.statuses.append(_elem125)
4801 anupam.sin 10024 
          iprot.readListEnd()
94 ashish 10025 
        else:
10026 
          iprot.skip(ftype)
483 rajveer 10027 
      elif fid == 2:
10028 
        if ftype == TType.I64:
10029 
          self.from_date = iprot.readI64();
94 ashish 10030 
        else:
10031 
          iprot.skip(ftype)
483 rajveer 10032 
      elif fid == 3:
10033 
        if ftype == TType.I64:
10034 
          self.to_date = iprot.readI64();
94 ashish 10035 
        else:
10036 
          iprot.skip(ftype)
483 rajveer 10037 
      elif fid == 4:
94 ashish 10038 
        if ftype == TType.I64:
483 rajveer 10039 
          self.warehouse_id = iprot.readI64();
94 ashish 10040 
        else:
10041 
          iprot.skip(ftype)
10042 
      else:
10043 
        iprot.skip(ftype)
10044 
      iprot.readFieldEnd()
10045 
    iprot.readStructEnd()
10046 
 
10047 
  def write(self, oprot):
10048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10050 
      return
483 rajveer 10051 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10052 
    if self.statuses is not None:
10053 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10054 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10055 
      for iter126 in self.statuses:
10056 
        oprot.writeI32(iter126)
4801 anupam.sin 10057 
      oprot.writeListEnd()
94 ashish 10058 
      oprot.writeFieldEnd()
3431 rajveer 10059 
    if self.from_date is not None:
483 rajveer 10060 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10061 
      oprot.writeI64(self.from_date)
94 ashish 10062 
      oprot.writeFieldEnd()
3431 rajveer 10063 
    if self.to_date is not None:
483 rajveer 10064 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10065 
      oprot.writeI64(self.to_date)
94 ashish 10066 
      oprot.writeFieldEnd()
3431 rajveer 10067 
    if self.warehouse_id is not None:
483 rajveer 10068 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10069 
      oprot.writeI64(self.warehouse_id)
94 ashish 10070 
      oprot.writeFieldEnd()
10071 
    oprot.writeFieldStop()
10072 
    oprot.writeStructEnd()
10073 
 
3431 rajveer 10074 
  def validate(self):
10075 
    return
10076 
 
10077 
 
94 ashish 10078 
  def __repr__(self):
10079 
    L = ['%s=%r' % (key, value)
10080 
      for key, value in self.__dict__.iteritems()]
10081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10082 
 
10083 
  def __eq__(self, other):
10084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10085 
 
10086 
  def __ne__(self, other):
10087 
    return not (self == other)
10088 
 
483 rajveer 10089 
class getAllOrders_result:
94 ashish 10090 
  """
10091 
  Attributes:
10092 
   - success
10093 
   - ex
10094 
  """
10095 
 
10096 
  thrift_spec = (
483 rajveer 10097 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10098 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10099 
  )
10100 
 
10101 
  def __init__(self, success=None, ex=None,):
10102 
    self.success = success
10103 
    self.ex = ex
10104 
 
10105 
  def read(self, iprot):
10106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10108 
      return
10109 
    iprot.readStructBegin()
10110 
    while True:
10111 
      (fname, ftype, fid) = iprot.readFieldBegin()
10112 
      if ftype == TType.STOP:
10113 
        break
10114 
      if fid == 0:
483 rajveer 10115 
        if ftype == TType.LIST:
10116 
          self.success = []
6188 rajveer 10117 
          (_etype130, _size127) = iprot.readListBegin()
10118 
          for _i131 in xrange(_size127):
10119 
            _elem132 = Order()
10120 
            _elem132.read(iprot)
10121 
            self.success.append(_elem132)
483 rajveer 10122 
          iprot.readListEnd()
94 ashish 10123 
        else:
10124 
          iprot.skip(ftype)
10125 
      elif fid == 1:
10126 
        if ftype == TType.STRUCT:
10127 
          self.ex = TransactionServiceException()
10128 
          self.ex.read(iprot)
10129 
        else:
10130 
          iprot.skip(ftype)
10131 
      else:
10132 
        iprot.skip(ftype)
10133 
      iprot.readFieldEnd()
10134 
    iprot.readStructEnd()
10135 
 
10136 
  def write(self, oprot):
10137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10139 
      return
483 rajveer 10140 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10141 
    if self.success is not None:
483 rajveer 10142 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10143 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10144 
      for iter133 in self.success:
10145 
        iter133.write(oprot)
483 rajveer 10146 
      oprot.writeListEnd()
94 ashish 10147 
      oprot.writeFieldEnd()
3431 rajveer 10148 
    if self.ex is not None:
94 ashish 10149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10150 
      self.ex.write(oprot)
10151 
      oprot.writeFieldEnd()
10152 
    oprot.writeFieldStop()
10153 
    oprot.writeStructEnd()
10154 
 
3431 rajveer 10155 
  def validate(self):
10156 
    return
10157 
 
10158 
 
94 ashish 10159 
  def __repr__(self):
10160 
    L = ['%s=%r' % (key, value)
10161 
      for key, value in self.__dict__.iteritems()]
10162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10163 
 
10164 
  def __eq__(self, other):
10165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10166 
 
10167 
  def __ne__(self, other):
10168 
    return not (self == other)
10169 
 
4133 chandransh 10170 
class getOrdersInBatch_args:
10171 
  """
10172 
  Attributes:
10173 
   - statuses
10174 
   - offset
10175 
   - limit
10176 
   - warehouse_id
10177 
  """
10178 
 
10179 
  thrift_spec = (
10180 
    None, # 0
10181 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10182 
    (2, TType.I64, 'offset', None, None, ), # 2
10183 
    (3, TType.I64, 'limit', None, None, ), # 3
10184 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10185 
  )
10186 
 
10187 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10188 
    self.statuses = statuses
10189 
    self.offset = offset
10190 
    self.limit = limit
10191 
    self.warehouse_id = warehouse_id
10192 
 
10193 
  def read(self, iprot):
10194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10196 
      return
10197 
    iprot.readStructBegin()
10198 
    while True:
10199 
      (fname, ftype, fid) = iprot.readFieldBegin()
10200 
      if ftype == TType.STOP:
10201 
        break
10202 
      if fid == 1:
10203 
        if ftype == TType.LIST:
10204 
          self.statuses = []
6188 rajveer 10205 
          (_etype137, _size134) = iprot.readListBegin()
10206 
          for _i138 in xrange(_size134):
10207 
            _elem139 = iprot.readI32();
10208 
            self.statuses.append(_elem139)
4133 chandransh 10209 
          iprot.readListEnd()
10210 
        else:
10211 
          iprot.skip(ftype)
10212 
      elif fid == 2:
10213 
        if ftype == TType.I64:
10214 
          self.offset = iprot.readI64();
10215 
        else:
10216 
          iprot.skip(ftype)
10217 
      elif fid == 3:
10218 
        if ftype == TType.I64:
10219 
          self.limit = iprot.readI64();
10220 
        else:
10221 
          iprot.skip(ftype)
10222 
      elif fid == 4:
10223 
        if ftype == TType.I64:
10224 
          self.warehouse_id = iprot.readI64();
10225 
        else:
10226 
          iprot.skip(ftype)
10227 
      else:
10228 
        iprot.skip(ftype)
10229 
      iprot.readFieldEnd()
10230 
    iprot.readStructEnd()
10231 
 
10232 
  def write(self, oprot):
10233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10235 
      return
10236 
    oprot.writeStructBegin('getOrdersInBatch_args')
10237 
    if self.statuses is not None:
10238 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10239 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10240 
      for iter140 in self.statuses:
10241 
        oprot.writeI32(iter140)
4133 chandransh 10242 
      oprot.writeListEnd()
10243 
      oprot.writeFieldEnd()
10244 
    if self.offset is not None:
10245 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10246 
      oprot.writeI64(self.offset)
10247 
      oprot.writeFieldEnd()
10248 
    if self.limit is not None:
10249 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10250 
      oprot.writeI64(self.limit)
10251 
      oprot.writeFieldEnd()
10252 
    if self.warehouse_id is not None:
10253 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10254 
      oprot.writeI64(self.warehouse_id)
10255 
      oprot.writeFieldEnd()
10256 
    oprot.writeFieldStop()
10257 
    oprot.writeStructEnd()
10258 
 
10259 
  def validate(self):
10260 
    return
10261 
 
10262 
 
10263 
  def __repr__(self):
10264 
    L = ['%s=%r' % (key, value)
10265 
      for key, value in self.__dict__.iteritems()]
10266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10267 
 
10268 
  def __eq__(self, other):
10269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10270 
 
10271 
  def __ne__(self, other):
10272 
    return not (self == other)
10273 
 
10274 
class getOrdersInBatch_result:
10275 
  """
10276 
  Attributes:
10277 
   - success
10278 
   - ex
10279 
  """
10280 
 
10281 
  thrift_spec = (
10282 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10284 
  )
10285 
 
10286 
  def __init__(self, success=None, ex=None,):
10287 
    self.success = success
10288 
    self.ex = ex
10289 
 
10290 
  def read(self, iprot):
10291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10293 
      return
10294 
    iprot.readStructBegin()
10295 
    while True:
10296 
      (fname, ftype, fid) = iprot.readFieldBegin()
10297 
      if ftype == TType.STOP:
10298 
        break
10299 
      if fid == 0:
10300 
        if ftype == TType.LIST:
10301 
          self.success = []
6188 rajveer 10302 
          (_etype144, _size141) = iprot.readListBegin()
10303 
          for _i145 in xrange(_size141):
10304 
            _elem146 = Order()
10305 
            _elem146.read(iprot)
10306 
            self.success.append(_elem146)
4133 chandransh 10307 
          iprot.readListEnd()
10308 
        else:
10309 
          iprot.skip(ftype)
10310 
      elif fid == 1:
10311 
        if ftype == TType.STRUCT:
10312 
          self.ex = TransactionServiceException()
10313 
          self.ex.read(iprot)
10314 
        else:
10315 
          iprot.skip(ftype)
10316 
      else:
10317 
        iprot.skip(ftype)
10318 
      iprot.readFieldEnd()
10319 
    iprot.readStructEnd()
10320 
 
10321 
  def write(self, oprot):
10322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10324 
      return
10325 
    oprot.writeStructBegin('getOrdersInBatch_result')
10326 
    if self.success is not None:
10327 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10328 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10329 
      for iter147 in self.success:
10330 
        iter147.write(oprot)
4133 chandransh 10331 
      oprot.writeListEnd()
10332 
      oprot.writeFieldEnd()
10333 
    if self.ex is not None:
10334 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10335 
      self.ex.write(oprot)
10336 
      oprot.writeFieldEnd()
10337 
    oprot.writeFieldStop()
10338 
    oprot.writeStructEnd()
10339 
 
10340 
  def validate(self):
10341 
    return
10342 
 
10343 
 
10344 
  def __repr__(self):
10345 
    L = ['%s=%r' % (key, value)
10346 
      for key, value in self.__dict__.iteritems()]
10347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10348 
 
10349 
  def __eq__(self, other):
10350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10351 
 
10352 
  def __ne__(self, other):
10353 
    return not (self == other)
10354 
 
10355 
class getOrderCount_args:
10356 
  """
10357 
  Attributes:
10358 
   - statuses
10359 
   - warehouseId
10360 
  """
10361 
 
10362 
  thrift_spec = (
10363 
    None, # 0
10364 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10365 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10366 
  )
10367 
 
10368 
  def __init__(self, statuses=None, warehouseId=None,):
10369 
    self.statuses = statuses
10370 
    self.warehouseId = warehouseId
10371 
 
10372 
  def read(self, iprot):
10373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10375 
      return
10376 
    iprot.readStructBegin()
10377 
    while True:
10378 
      (fname, ftype, fid) = iprot.readFieldBegin()
10379 
      if ftype == TType.STOP:
10380 
        break
10381 
      if fid == 1:
10382 
        if ftype == TType.LIST:
10383 
          self.statuses = []
6188 rajveer 10384 
          (_etype151, _size148) = iprot.readListBegin()
10385 
          for _i152 in xrange(_size148):
10386 
            _elem153 = iprot.readI32();
10387 
            self.statuses.append(_elem153)
4133 chandransh 10388 
          iprot.readListEnd()
10389 
        else:
10390 
          iprot.skip(ftype)
10391 
      elif fid == 2:
10392 
        if ftype == TType.I64:
10393 
          self.warehouseId = iprot.readI64();
10394 
        else:
10395 
          iprot.skip(ftype)
10396 
      else:
10397 
        iprot.skip(ftype)
10398 
      iprot.readFieldEnd()
10399 
    iprot.readStructEnd()
10400 
 
10401 
  def write(self, oprot):
10402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10404 
      return
10405 
    oprot.writeStructBegin('getOrderCount_args')
10406 
    if self.statuses is not None:
10407 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10408 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10409 
      for iter154 in self.statuses:
10410 
        oprot.writeI32(iter154)
4133 chandransh 10411 
      oprot.writeListEnd()
10412 
      oprot.writeFieldEnd()
10413 
    if self.warehouseId is not None:
10414 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10415 
      oprot.writeI64(self.warehouseId)
10416 
      oprot.writeFieldEnd()
10417 
    oprot.writeFieldStop()
10418 
    oprot.writeStructEnd()
10419 
 
10420 
  def validate(self):
10421 
    return
10422 
 
10423 
 
10424 
  def __repr__(self):
10425 
    L = ['%s=%r' % (key, value)
10426 
      for key, value in self.__dict__.iteritems()]
10427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10428 
 
10429 
  def __eq__(self, other):
10430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10431 
 
10432 
  def __ne__(self, other):
10433 
    return not (self == other)
10434 
 
10435 
class getOrderCount_result:
10436 
  """
10437 
  Attributes:
10438 
   - success
10439 
   - ex
10440 
  """
10441 
 
10442 
  thrift_spec = (
10443 
    (0, TType.I32, 'success', None, None, ), # 0
10444 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10445 
  )
10446 
 
10447 
  def __init__(self, success=None, ex=None,):
10448 
    self.success = success
10449 
    self.ex = ex
10450 
 
10451 
  def read(self, iprot):
10452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10454 
      return
10455 
    iprot.readStructBegin()
10456 
    while True:
10457 
      (fname, ftype, fid) = iprot.readFieldBegin()
10458 
      if ftype == TType.STOP:
10459 
        break
10460 
      if fid == 0:
10461 
        if ftype == TType.I32:
10462 
          self.success = iprot.readI32();
10463 
        else:
10464 
          iprot.skip(ftype)
10465 
      elif fid == 1:
10466 
        if ftype == TType.STRUCT:
10467 
          self.ex = TransactionServiceException()
10468 
          self.ex.read(iprot)
10469 
        else:
10470 
          iprot.skip(ftype)
10471 
      else:
10472 
        iprot.skip(ftype)
10473 
      iprot.readFieldEnd()
10474 
    iprot.readStructEnd()
10475 
 
10476 
  def write(self, oprot):
10477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10479 
      return
10480 
    oprot.writeStructBegin('getOrderCount_result')
10481 
    if self.success is not None:
10482 
      oprot.writeFieldBegin('success', TType.I32, 0)
10483 
      oprot.writeI32(self.success)
10484 
      oprot.writeFieldEnd()
10485 
    if self.ex is not None:
10486 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10487 
      self.ex.write(oprot)
10488 
      oprot.writeFieldEnd()
10489 
    oprot.writeFieldStop()
10490 
    oprot.writeStructEnd()
10491 
 
10492 
  def validate(self):
10493 
    return
10494 
 
10495 
 
10496 
  def __repr__(self):
10497 
    L = ['%s=%r' % (key, value)
10498 
      for key, value in self.__dict__.iteritems()]
10499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10500 
 
10501 
  def __eq__(self, other):
10502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10503 
 
10504 
  def __ne__(self, other):
10505 
    return not (self == other)
10506 
 
999 varun.gupt 10507 
class getOrdersByBillingDate_args:
10508 
  """
10509 
  Attributes:
10510 
   - status
10511 
   - start_billing_date
10512 
   - end_billing_date
10513 
   - warehouse_id
10514 
  """
10515 
 
10516 
  thrift_spec = (
10517 
    None, # 0
10518 
    (1, TType.I32, 'status', None, None, ), # 1
10519 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10520 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10521 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10522 
  )
10523 
 
10524 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10525 
    self.status = status
10526 
    self.start_billing_date = start_billing_date
10527 
    self.end_billing_date = end_billing_date
10528 
    self.warehouse_id = warehouse_id
10529 
 
10530 
  def read(self, iprot):
10531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10533 
      return
10534 
    iprot.readStructBegin()
10535 
    while True:
10536 
      (fname, ftype, fid) = iprot.readFieldBegin()
10537 
      if ftype == TType.STOP:
10538 
        break
10539 
      if fid == 1:
10540 
        if ftype == TType.I32:
10541 
          self.status = iprot.readI32();
10542 
        else:
10543 
          iprot.skip(ftype)
10544 
      elif fid == 2:
10545 
        if ftype == TType.I64:
10546 
          self.start_billing_date = iprot.readI64();
10547 
        else:
10548 
          iprot.skip(ftype)
10549 
      elif fid == 3:
10550 
        if ftype == TType.I64:
10551 
          self.end_billing_date = iprot.readI64();
10552 
        else:
10553 
          iprot.skip(ftype)
10554 
      elif fid == 4:
10555 
        if ftype == TType.I64:
10556 
          self.warehouse_id = iprot.readI64();
10557 
        else:
10558 
          iprot.skip(ftype)
10559 
      else:
10560 
        iprot.skip(ftype)
10561 
      iprot.readFieldEnd()
10562 
    iprot.readStructEnd()
10563 
 
10564 
  def write(self, oprot):
10565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10567 
      return
10568 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10569 
    if self.status is not None:
999 varun.gupt 10570 
      oprot.writeFieldBegin('status', TType.I32, 1)
10571 
      oprot.writeI32(self.status)
10572 
      oprot.writeFieldEnd()
3431 rajveer 10573 
    if self.start_billing_date is not None:
999 varun.gupt 10574 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10575 
      oprot.writeI64(self.start_billing_date)
10576 
      oprot.writeFieldEnd()
3431 rajveer 10577 
    if self.end_billing_date is not None:
999 varun.gupt 10578 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10579 
      oprot.writeI64(self.end_billing_date)
10580 
      oprot.writeFieldEnd()
3431 rajveer 10581 
    if self.warehouse_id is not None:
999 varun.gupt 10582 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10583 
      oprot.writeI64(self.warehouse_id)
10584 
      oprot.writeFieldEnd()
10585 
    oprot.writeFieldStop()
10586 
    oprot.writeStructEnd()
10587 
 
3431 rajveer 10588 
  def validate(self):
10589 
    return
10590 
 
10591 
 
999 varun.gupt 10592 
  def __repr__(self):
10593 
    L = ['%s=%r' % (key, value)
10594 
      for key, value in self.__dict__.iteritems()]
10595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10596 
 
10597 
  def __eq__(self, other):
10598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10599 
 
10600 
  def __ne__(self, other):
10601 
    return not (self == other)
10602 
 
10603 
class getOrdersByBillingDate_result:
10604 
  """
10605 
  Attributes:
10606 
   - success
10607 
   - ex
10608 
  """
10609 
 
10610 
  thrift_spec = (
10611 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10612 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10613 
  )
10614 
 
10615 
  def __init__(self, success=None, ex=None,):
10616 
    self.success = success
10617 
    self.ex = ex
10618 
 
10619 
  def read(self, iprot):
10620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10622 
      return
10623 
    iprot.readStructBegin()
10624 
    while True:
10625 
      (fname, ftype, fid) = iprot.readFieldBegin()
10626 
      if ftype == TType.STOP:
10627 
        break
10628 
      if fid == 0:
10629 
        if ftype == TType.LIST:
10630 
          self.success = []
6188 rajveer 10631 
          (_etype158, _size155) = iprot.readListBegin()
10632 
          for _i159 in xrange(_size155):
10633 
            _elem160 = Order()
10634 
            _elem160.read(iprot)
10635 
            self.success.append(_elem160)
999 varun.gupt 10636 
          iprot.readListEnd()
10637 
        else:
10638 
          iprot.skip(ftype)
10639 
      elif fid == 1:
10640 
        if ftype == TType.STRUCT:
10641 
          self.ex = TransactionServiceException()
10642 
          self.ex.read(iprot)
10643 
        else:
10644 
          iprot.skip(ftype)
10645 
      else:
10646 
        iprot.skip(ftype)
10647 
      iprot.readFieldEnd()
10648 
    iprot.readStructEnd()
10649 
 
10650 
  def write(self, oprot):
10651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10653 
      return
10654 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10655 
    if self.success is not None:
999 varun.gupt 10656 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10657 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10658 
      for iter161 in self.success:
10659 
        iter161.write(oprot)
999 varun.gupt 10660 
      oprot.writeListEnd()
10661 
      oprot.writeFieldEnd()
3431 rajveer 10662 
    if self.ex is not None:
999 varun.gupt 10663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10664 
      self.ex.write(oprot)
10665 
      oprot.writeFieldEnd()
10666 
    oprot.writeFieldStop()
10667 
    oprot.writeStructEnd()
10668 
 
3431 rajveer 10669 
  def validate(self):
10670 
    return
10671 
 
10672 
 
999 varun.gupt 10673 
  def __repr__(self):
10674 
    L = ['%s=%r' % (key, value)
10675 
      for key, value in self.__dict__.iteritems()]
10676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10677 
 
10678 
  def __eq__(self, other):
10679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10680 
 
10681 
  def __ne__(self, other):
10682 
    return not (self == other)
10683 
 
3427 chandransh 10684 
class getOrdersByShippingDate_args:
10685 
  """
10686 
  Attributes:
10687 
   - fromShippingDate
10688 
   - toShippingDate
10689 
   - providerId
10690 
   - warehouseId
3451 chandransh 10691 
   - cod
3427 chandransh 10692 
  """
10693 
 
10694 
  thrift_spec = (
10695 
    None, # 0
10696 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10697 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10698 
    (3, TType.I64, 'providerId', None, None, ), # 3
10699 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10700 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10701 
  )
10702 
 
3451 chandransh 10703 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10704 
    self.fromShippingDate = fromShippingDate
10705 
    self.toShippingDate = toShippingDate
10706 
    self.providerId = providerId
10707 
    self.warehouseId = warehouseId
3451 chandransh 10708 
    self.cod = cod
3427 chandransh 10709 
 
10710 
  def read(self, iprot):
10711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10713 
      return
10714 
    iprot.readStructBegin()
10715 
    while True:
10716 
      (fname, ftype, fid) = iprot.readFieldBegin()
10717 
      if ftype == TType.STOP:
10718 
        break
10719 
      if fid == 1:
10720 
        if ftype == TType.I64:
10721 
          self.fromShippingDate = iprot.readI64();
10722 
        else:
10723 
          iprot.skip(ftype)
10724 
      elif fid == 2:
10725 
        if ftype == TType.I64:
10726 
          self.toShippingDate = iprot.readI64();
10727 
        else:
10728 
          iprot.skip(ftype)
10729 
      elif fid == 3:
10730 
        if ftype == TType.I64:
10731 
          self.providerId = iprot.readI64();
10732 
        else:
10733 
          iprot.skip(ftype)
10734 
      elif fid == 4:
10735 
        if ftype == TType.I64:
10736 
          self.warehouseId = iprot.readI64();
10737 
        else:
10738 
          iprot.skip(ftype)
3451 chandransh 10739 
      elif fid == 5:
10740 
        if ftype == TType.BOOL:
10741 
          self.cod = iprot.readBool();
10742 
        else:
10743 
          iprot.skip(ftype)
3427 chandransh 10744 
      else:
10745 
        iprot.skip(ftype)
10746 
      iprot.readFieldEnd()
10747 
    iprot.readStructEnd()
10748 
 
10749 
  def write(self, oprot):
10750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10752 
      return
10753 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10754 
    if self.fromShippingDate is not None:
3427 chandransh 10755 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10756 
      oprot.writeI64(self.fromShippingDate)
10757 
      oprot.writeFieldEnd()
3431 rajveer 10758 
    if self.toShippingDate is not None:
3427 chandransh 10759 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10760 
      oprot.writeI64(self.toShippingDate)
10761 
      oprot.writeFieldEnd()
3431 rajveer 10762 
    if self.providerId is not None:
3427 chandransh 10763 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10764 
      oprot.writeI64(self.providerId)
10765 
      oprot.writeFieldEnd()
3431 rajveer 10766 
    if self.warehouseId is not None:
3427 chandransh 10767 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10768 
      oprot.writeI64(self.warehouseId)
10769 
      oprot.writeFieldEnd()
3451 chandransh 10770 
    if self.cod is not None:
10771 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10772 
      oprot.writeBool(self.cod)
10773 
      oprot.writeFieldEnd()
3427 chandransh 10774 
    oprot.writeFieldStop()
10775 
    oprot.writeStructEnd()
10776 
 
3431 rajveer 10777 
  def validate(self):
10778 
    return
10779 
 
10780 
 
3427 chandransh 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 
 
10792 
class getOrdersByShippingDate_result:
10793 
  """
10794 
  Attributes:
10795 
   - success
10796 
   - ex
10797 
  """
10798 
 
10799 
  thrift_spec = (
10800 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
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:
10818 
        if ftype == TType.LIST:
10819 
          self.success = []
6188 rajveer 10820 
          (_etype165, _size162) = iprot.readListBegin()
10821 
          for _i166 in xrange(_size162):
10822 
            _elem167 = Order()
10823 
            _elem167.read(iprot)
10824 
            self.success.append(_elem167)
3427 chandransh 10825 
          iprot.readListEnd()
10826 
        else:
10827 
          iprot.skip(ftype)
10828 
      elif fid == 1:
10829 
        if ftype == TType.STRUCT:
10830 
          self.ex = TransactionServiceException()
10831 
          self.ex.read(iprot)
10832 
        else:
10833 
          iprot.skip(ftype)
10834 
      else:
10835 
        iprot.skip(ftype)
10836 
      iprot.readFieldEnd()
10837 
    iprot.readStructEnd()
10838 
 
10839 
  def write(self, oprot):
10840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10842 
      return
10843 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10844 
    if self.success is not None:
3427 chandransh 10845 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10846 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10847 
      for iter168 in self.success:
10848 
        iter168.write(oprot)
3427 chandransh 10849 
      oprot.writeListEnd()
10850 
      oprot.writeFieldEnd()
3431 rajveer 10851 
    if self.ex is not None:
3427 chandransh 10852 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10853 
      self.ex.write(oprot)
10854 
      oprot.writeFieldEnd()
10855 
    oprot.writeFieldStop()
10856 
    oprot.writeStructEnd()
10857 
 
3431 rajveer 10858 
  def validate(self):
10859 
    return
10860 
 
10861 
 
3427 chandransh 10862 
  def __repr__(self):
10863 
    L = ['%s=%r' % (key, value)
10864 
      for key, value in self.__dict__.iteritems()]
10865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10866 
 
10867 
  def __eq__(self, other):
10868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10869 
 
10870 
  def __ne__(self, other):
10871 
    return not (self == other)
10872 
 
1382 varun.gupt 10873 
class getReturnableOrdersForCustomer_args:
10874 
  """
10875 
  Attributes:
10876 
   - customer_id
10877 
   - limit
10878 
  """
10879 
 
10880 
  thrift_spec = (
10881 
    None, # 0
10882 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10883 
    (2, TType.I64, 'limit', None, None, ), # 2
10884 
  )
10885 
 
10886 
  def __init__(self, customer_id=None, limit=None,):
10887 
    self.customer_id = customer_id
10888 
    self.limit = limit
10889 
 
10890 
  def read(self, iprot):
10891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10893 
      return
10894 
    iprot.readStructBegin()
10895 
    while True:
10896 
      (fname, ftype, fid) = iprot.readFieldBegin()
10897 
      if ftype == TType.STOP:
10898 
        break
10899 
      if fid == 1:
10900 
        if ftype == TType.I64:
10901 
          self.customer_id = iprot.readI64();
10902 
        else:
10903 
          iprot.skip(ftype)
10904 
      elif fid == 2:
10905 
        if ftype == TType.I64:
10906 
          self.limit = iprot.readI64();
10907 
        else:
10908 
          iprot.skip(ftype)
10909 
      else:
10910 
        iprot.skip(ftype)
10911 
      iprot.readFieldEnd()
10912 
    iprot.readStructEnd()
10913 
 
10914 
  def write(self, oprot):
10915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10917 
      return
10918 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10919 
    if self.customer_id is not None:
1382 varun.gupt 10920 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10921 
      oprot.writeI64(self.customer_id)
10922 
      oprot.writeFieldEnd()
3431 rajveer 10923 
    if self.limit is not None:
1382 varun.gupt 10924 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10925 
      oprot.writeI64(self.limit)
10926 
      oprot.writeFieldEnd()
10927 
    oprot.writeFieldStop()
10928 
    oprot.writeStructEnd()
10929 
 
3431 rajveer 10930 
  def validate(self):
10931 
    return
10932 
 
10933 
 
1382 varun.gupt 10934 
  def __repr__(self):
10935 
    L = ['%s=%r' % (key, value)
10936 
      for key, value in self.__dict__.iteritems()]
10937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10938 
 
10939 
  def __eq__(self, other):
10940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10941 
 
10942 
  def __ne__(self, other):
10943 
    return not (self == other)
10944 
 
10945 
class getReturnableOrdersForCustomer_result:
10946 
  """
10947 
  Attributes:
10948 
   - success
10949 
   - ex
10950 
  """
10951 
 
10952 
  thrift_spec = (
10953 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10954 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10955 
  )
10956 
 
10957 
  def __init__(self, success=None, ex=None,):
10958 
    self.success = success
10959 
    self.ex = ex
10960 
 
10961 
  def read(self, iprot):
10962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10964 
      return
10965 
    iprot.readStructBegin()
10966 
    while True:
10967 
      (fname, ftype, fid) = iprot.readFieldBegin()
10968 
      if ftype == TType.STOP:
10969 
        break
10970 
      if fid == 0:
10971 
        if ftype == TType.LIST:
10972 
          self.success = []
6188 rajveer 10973 
          (_etype172, _size169) = iprot.readListBegin()
10974 
          for _i173 in xrange(_size169):
10975 
            _elem174 = iprot.readI64();
10976 
            self.success.append(_elem174)
1382 varun.gupt 10977 
          iprot.readListEnd()
10978 
        else:
10979 
          iprot.skip(ftype)
10980 
      elif fid == 1:
10981 
        if ftype == TType.STRUCT:
10982 
          self.ex = TransactionServiceException()
10983 
          self.ex.read(iprot)
10984 
        else:
10985 
          iprot.skip(ftype)
10986 
      else:
10987 
        iprot.skip(ftype)
10988 
      iprot.readFieldEnd()
10989 
    iprot.readStructEnd()
10990 
 
10991 
  def write(self, oprot):
10992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10994 
      return
10995 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10996 
    if self.success is not None:
1382 varun.gupt 10997 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10998 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10999 
      for iter175 in self.success:
11000 
        oprot.writeI64(iter175)
1382 varun.gupt 11001 
      oprot.writeListEnd()
11002 
      oprot.writeFieldEnd()
3431 rajveer 11003 
    if self.ex is not None:
1382 varun.gupt 11004 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11005 
      self.ex.write(oprot)
11006 
      oprot.writeFieldEnd()
11007 
    oprot.writeFieldStop()
11008 
    oprot.writeStructEnd()
11009 
 
3431 rajveer 11010 
  def validate(self):
11011 
    return
11012 
 
11013 
 
1382 varun.gupt 11014 
  def __repr__(self):
11015 
    L = ['%s=%r' % (key, value)
11016 
      for key, value in self.__dict__.iteritems()]
11017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11018 
 
11019 
  def __eq__(self, other):
11020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11021 
 
11022 
  def __ne__(self, other):
11023 
    return not (self == other)
11024 
 
11025 
class getCancellableOrdersForCustomer_args:
11026 
  """
11027 
  Attributes:
11028 
   - customer_id
11029 
   - limit
11030 
  """
11031 
 
11032 
  thrift_spec = (
11033 
    None, # 0
11034 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11035 
    (2, TType.I64, 'limit', None, None, ), # 2
11036 
  )
11037 
 
11038 
  def __init__(self, customer_id=None, limit=None,):
11039 
    self.customer_id = customer_id
11040 
    self.limit = limit
11041 
 
11042 
  def read(self, iprot):
11043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11045 
      return
11046 
    iprot.readStructBegin()
11047 
    while True:
11048 
      (fname, ftype, fid) = iprot.readFieldBegin()
11049 
      if ftype == TType.STOP:
11050 
        break
11051 
      if fid == 1:
11052 
        if ftype == TType.I64:
11053 
          self.customer_id = iprot.readI64();
11054 
        else:
11055 
          iprot.skip(ftype)
11056 
      elif fid == 2:
11057 
        if ftype == TType.I64:
11058 
          self.limit = iprot.readI64();
11059 
        else:
11060 
          iprot.skip(ftype)
11061 
      else:
11062 
        iprot.skip(ftype)
11063 
      iprot.readFieldEnd()
11064 
    iprot.readStructEnd()
11065 
 
11066 
  def write(self, oprot):
11067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11069 
      return
11070 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11071 
    if self.customer_id is not None:
1382 varun.gupt 11072 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11073 
      oprot.writeI64(self.customer_id)
11074 
      oprot.writeFieldEnd()
3431 rajveer 11075 
    if self.limit is not None:
1382 varun.gupt 11076 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11077 
      oprot.writeI64(self.limit)
11078 
      oprot.writeFieldEnd()
11079 
    oprot.writeFieldStop()
11080 
    oprot.writeStructEnd()
11081 
 
3431 rajveer 11082 
  def validate(self):
11083 
    return
11084 
 
11085 
 
1382 varun.gupt 11086 
  def __repr__(self):
11087 
    L = ['%s=%r' % (key, value)
11088 
      for key, value in self.__dict__.iteritems()]
11089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11090 
 
11091 
  def __eq__(self, other):
11092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11093 
 
11094 
  def __ne__(self, other):
11095 
    return not (self == other)
11096 
 
11097 
class getCancellableOrdersForCustomer_result:
11098 
  """
11099 
  Attributes:
11100 
   - success
11101 
   - ex
11102 
  """
11103 
 
11104 
  thrift_spec = (
11105 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11107 
  )
11108 
 
11109 
  def __init__(self, success=None, ex=None,):
11110 
    self.success = success
11111 
    self.ex = ex
11112 
 
11113 
  def read(self, iprot):
11114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11116 
      return
11117 
    iprot.readStructBegin()
11118 
    while True:
11119 
      (fname, ftype, fid) = iprot.readFieldBegin()
11120 
      if ftype == TType.STOP:
11121 
        break
11122 
      if fid == 0:
11123 
        if ftype == TType.LIST:
11124 
          self.success = []
6188 rajveer 11125 
          (_etype179, _size176) = iprot.readListBegin()
11126 
          for _i180 in xrange(_size176):
11127 
            _elem181 = iprot.readI64();
11128 
            self.success.append(_elem181)
1382 varun.gupt 11129 
          iprot.readListEnd()
11130 
        else:
11131 
          iprot.skip(ftype)
11132 
      elif fid == 1:
11133 
        if ftype == TType.STRUCT:
11134 
          self.ex = TransactionServiceException()
11135 
          self.ex.read(iprot)
11136 
        else:
11137 
          iprot.skip(ftype)
11138 
      else:
11139 
        iprot.skip(ftype)
11140 
      iprot.readFieldEnd()
11141 
    iprot.readStructEnd()
11142 
 
11143 
  def write(self, oprot):
11144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11146 
      return
11147 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11148 
    if self.success is not None:
1382 varun.gupt 11149 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11150 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11151 
      for iter182 in self.success:
11152 
        oprot.writeI64(iter182)
1382 varun.gupt 11153 
      oprot.writeListEnd()
11154 
      oprot.writeFieldEnd()
3431 rajveer 11155 
    if self.ex is not None:
1382 varun.gupt 11156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11157 
      self.ex.write(oprot)
11158 
      oprot.writeFieldEnd()
11159 
    oprot.writeFieldStop()
11160 
    oprot.writeStructEnd()
11161 
 
3431 rajveer 11162 
  def validate(self):
11163 
    return
11164 
 
11165 
 
1382 varun.gupt 11166 
  def __repr__(self):
11167 
    L = ['%s=%r' % (key, value)
11168 
      for key, value in self.__dict__.iteritems()]
11169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11170 
 
11171 
  def __eq__(self, other):
11172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11173 
 
11174 
  def __ne__(self, other):
11175 
    return not (self == other)
11176 
 
483 rajveer 11177 
class changeOrderStatus_args:
94 ashish 11178 
  """
11179 
  Attributes:
483 rajveer 11180 
   - orderId
11181 
   - status
11182 
   - description
94 ashish 11183 
  """
11184 
 
11185 
  thrift_spec = (
11186 
    None, # 0
483 rajveer 11187 
    (1, TType.I64, 'orderId', None, None, ), # 1
11188 
    (2, TType.I32, 'status', None, None, ), # 2
11189 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11190 
  )
11191 
 
483 rajveer 11192 
  def __init__(self, orderId=None, status=None, description=None,):
11193 
    self.orderId = orderId
11194 
    self.status = status
11195 
    self.description = description
94 ashish 11196 
 
11197 
  def read(self, iprot):
11198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11200 
      return
11201 
    iprot.readStructBegin()
11202 
    while True:
11203 
      (fname, ftype, fid) = iprot.readFieldBegin()
11204 
      if ftype == TType.STOP:
11205 
        break
11206 
      if fid == 1:
11207 
        if ftype == TType.I64:
483 rajveer 11208 
          self.orderId = iprot.readI64();
94 ashish 11209 
        else:
11210 
          iprot.skip(ftype)
11211 
      elif fid == 2:
483 rajveer 11212 
        if ftype == TType.I32:
11213 
          self.status = iprot.readI32();
94 ashish 11214 
        else:
11215 
          iprot.skip(ftype)
483 rajveer 11216 
      elif fid == 3:
11217 
        if ftype == TType.STRING:
11218 
          self.description = iprot.readString();
11219 
        else:
11220 
          iprot.skip(ftype)
94 ashish 11221 
      else:
11222 
        iprot.skip(ftype)
11223 
      iprot.readFieldEnd()
11224 
    iprot.readStructEnd()
11225 
 
11226 
  def write(self, oprot):
11227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11229 
      return
483 rajveer 11230 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11231 
    if self.orderId is not None:
483 rajveer 11232 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11233 
      oprot.writeI64(self.orderId)
94 ashish 11234 
      oprot.writeFieldEnd()
3431 rajveer 11235 
    if self.status is not None:
483 rajveer 11236 
      oprot.writeFieldBegin('status', TType.I32, 2)
11237 
      oprot.writeI32(self.status)
94 ashish 11238 
      oprot.writeFieldEnd()
3431 rajveer 11239 
    if self.description is not None:
483 rajveer 11240 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11241 
      oprot.writeString(self.description)
11242 
      oprot.writeFieldEnd()
94 ashish 11243 
    oprot.writeFieldStop()
11244 
    oprot.writeStructEnd()
11245 
 
3431 rajveer 11246 
  def validate(self):
11247 
    return
11248 
 
11249 
 
94 ashish 11250 
  def __repr__(self):
11251 
    L = ['%s=%r' % (key, value)
11252 
      for key, value in self.__dict__.iteritems()]
11253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11254 
 
11255 
  def __eq__(self, other):
11256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11257 
 
11258 
  def __ne__(self, other):
11259 
    return not (self == other)
11260 
 
483 rajveer 11261 
class changeOrderStatus_result:
94 ashish 11262 
  """
11263 
  Attributes:
11264 
   - success
11265 
   - ex
11266 
  """
11267 
 
11268 
  thrift_spec = (
11269 
    (0, TType.BOOL, 'success', None, None, ), # 0
11270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11271 
  )
11272 
 
11273 
  def __init__(self, success=None, ex=None,):
11274 
    self.success = success
11275 
    self.ex = ex
11276 
 
11277 
  def read(self, iprot):
11278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11280 
      return
11281 
    iprot.readStructBegin()
11282 
    while True:
11283 
      (fname, ftype, fid) = iprot.readFieldBegin()
11284 
      if ftype == TType.STOP:
11285 
        break
11286 
      if fid == 0:
11287 
        if ftype == TType.BOOL:
11288 
          self.success = iprot.readBool();
11289 
        else:
11290 
          iprot.skip(ftype)
11291 
      elif fid == 1:
11292 
        if ftype == TType.STRUCT:
11293 
          self.ex = TransactionServiceException()
11294 
          self.ex.read(iprot)
11295 
        else:
11296 
          iprot.skip(ftype)
11297 
      else:
11298 
        iprot.skip(ftype)
11299 
      iprot.readFieldEnd()
11300 
    iprot.readStructEnd()
11301 
 
11302 
  def write(self, oprot):
11303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11305 
      return
483 rajveer 11306 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11307 
    if self.success is not None:
94 ashish 11308 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11309 
      oprot.writeBool(self.success)
11310 
      oprot.writeFieldEnd()
3431 rajveer 11311 
    if self.ex is not None:
94 ashish 11312 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11313 
      self.ex.write(oprot)
11314 
      oprot.writeFieldEnd()
11315 
    oprot.writeFieldStop()
11316 
    oprot.writeStructEnd()
11317 
 
3431 rajveer 11318 
  def validate(self):
11319 
    return
11320 
 
11321 
 
94 ashish 11322 
  def __repr__(self):
11323 
    L = ['%s=%r' % (key, value)
11324 
      for key, value in self.__dict__.iteritems()]
11325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11326 
 
11327 
  def __eq__(self, other):
11328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11329 
 
11330 
  def __ne__(self, other):
11331 
    return not (self == other)
11332 
 
3064 chandransh 11333 
class getOrdersForTransaction_args:
494 rajveer 11334 
  """
11335 
  Attributes:
3064 chandransh 11336 
   - transactionId
11337 
   - customerId
494 rajveer 11338 
  """
11339 
 
11340 
  thrift_spec = (
11341 
    None, # 0
3064 chandransh 11342 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11343 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11344 
  )
11345 
 
3064 chandransh 11346 
  def __init__(self, transactionId=None, customerId=None,):
11347 
    self.transactionId = transactionId
11348 
    self.customerId = customerId
494 rajveer 11349 
 
11350 
  def read(self, iprot):
11351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11353 
      return
11354 
    iprot.readStructBegin()
11355 
    while True:
11356 
      (fname, ftype, fid) = iprot.readFieldBegin()
11357 
      if ftype == TType.STOP:
11358 
        break
11359 
      if fid == 1:
11360 
        if ftype == TType.I64:
3064 chandransh 11361 
          self.transactionId = iprot.readI64();
494 rajveer 11362 
        else:
11363 
          iprot.skip(ftype)
11364 
      elif fid == 2:
3064 chandransh 11365 
        if ftype == TType.I64:
11366 
          self.customerId = iprot.readI64();
494 rajveer 11367 
        else:
11368 
          iprot.skip(ftype)
11369 
      else:
11370 
        iprot.skip(ftype)
11371 
      iprot.readFieldEnd()
11372 
    iprot.readStructEnd()
11373 
 
11374 
  def write(self, oprot):
11375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11377 
      return
3064 chandransh 11378 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11379 
    if self.transactionId is not None:
3064 chandransh 11380 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11381 
      oprot.writeI64(self.transactionId)
494 rajveer 11382 
      oprot.writeFieldEnd()
3431 rajveer 11383 
    if self.customerId is not None:
3064 chandransh 11384 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11385 
      oprot.writeI64(self.customerId)
494 rajveer 11386 
      oprot.writeFieldEnd()
11387 
    oprot.writeFieldStop()
11388 
    oprot.writeStructEnd()
11389 
 
3431 rajveer 11390 
  def validate(self):
11391 
    return
11392 
 
11393 
 
494 rajveer 11394 
  def __repr__(self):
11395 
    L = ['%s=%r' % (key, value)
11396 
      for key, value in self.__dict__.iteritems()]
11397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11398 
 
11399 
  def __eq__(self, other):
11400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11401 
 
11402 
  def __ne__(self, other):
11403 
    return not (self == other)
11404 
 
3064 chandransh 11405 
class getOrdersForTransaction_result:
494 rajveer 11406 
  """
11407 
  Attributes:
11408 
   - success
11409 
   - ex
11410 
  """
11411 
 
11412 
  thrift_spec = (
3064 chandransh 11413 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11415 
  )
11416 
 
11417 
  def __init__(self, success=None, ex=None,):
11418 
    self.success = success
11419 
    self.ex = ex
11420 
 
11421 
  def read(self, iprot):
11422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11424 
      return
11425 
    iprot.readStructBegin()
11426 
    while True:
11427 
      (fname, ftype, fid) = iprot.readFieldBegin()
11428 
      if ftype == TType.STOP:
11429 
        break
11430 
      if fid == 0:
3064 chandransh 11431 
        if ftype == TType.LIST:
11432 
          self.success = []
6188 rajveer 11433 
          (_etype186, _size183) = iprot.readListBegin()
11434 
          for _i187 in xrange(_size183):
11435 
            _elem188 = Order()
11436 
            _elem188.read(iprot)
11437 
            self.success.append(_elem188)
3064 chandransh 11438 
          iprot.readListEnd()
494 rajveer 11439 
        else:
11440 
          iprot.skip(ftype)
11441 
      elif fid == 1:
11442 
        if ftype == TType.STRUCT:
11443 
          self.ex = TransactionServiceException()
11444 
          self.ex.read(iprot)
11445 
        else:
11446 
          iprot.skip(ftype)
11447 
      else:
11448 
        iprot.skip(ftype)
11449 
      iprot.readFieldEnd()
11450 
    iprot.readStructEnd()
11451 
 
11452 
  def write(self, oprot):
11453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11455 
      return
3064 chandransh 11456 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11457 
    if self.success is not None:
3064 chandransh 11458 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11459 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11460 
      for iter189 in self.success:
11461 
        iter189.write(oprot)
3064 chandransh 11462 
      oprot.writeListEnd()
494 rajveer 11463 
      oprot.writeFieldEnd()
3431 rajveer 11464 
    if self.ex is not None:
494 rajveer 11465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11466 
      self.ex.write(oprot)
11467 
      oprot.writeFieldEnd()
11468 
    oprot.writeFieldStop()
11469 
    oprot.writeStructEnd()
11470 
 
3431 rajveer 11471 
  def validate(self):
11472 
    return
11473 
 
11474 
 
494 rajveer 11475 
  def __repr__(self):
11476 
    L = ['%s=%r' % (key, value)
11477 
      for key, value in self.__dict__.iteritems()]
11478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11479 
 
11480 
  def __eq__(self, other):
11481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11482 
 
11483 
  def __ne__(self, other):
11484 
    return not (self == other)
11485 
 
3064 chandransh 11486 
class getOrdersForCustomer_args:
1149 chandransh 11487 
  """
11488 
  Attributes:
3064 chandransh 11489 
   - customerId
11490 
   - from_date
11491 
   - to_date
11492 
   - statuses
1149 chandransh 11493 
  """
11494 
 
11495 
  thrift_spec = (
11496 
    None, # 0
3064 chandransh 11497 
    (1, TType.I64, 'customerId', None, None, ), # 1
11498 
    (2, TType.I64, 'from_date', None, None, ), # 2
11499 
    (3, TType.I64, 'to_date', None, None, ), # 3
11500 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11501 
  )
11502 
 
3064 chandransh 11503 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11504 
    self.customerId = customerId
11505 
    self.from_date = from_date
11506 
    self.to_date = to_date
11507 
    self.statuses = statuses
1149 chandransh 11508 
 
11509 
  def read(self, iprot):
11510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11512 
      return
11513 
    iprot.readStructBegin()
11514 
    while True:
11515 
      (fname, ftype, fid) = iprot.readFieldBegin()
11516 
      if ftype == TType.STOP:
11517 
        break
11518 
      if fid == 1:
11519 
        if ftype == TType.I64:
3064 chandransh 11520 
          self.customerId = iprot.readI64();
1149 chandransh 11521 
        else:
11522 
          iprot.skip(ftype)
11523 
      elif fid == 2:
11524 
        if ftype == TType.I64:
3064 chandransh 11525 
          self.from_date = iprot.readI64();
1149 chandransh 11526 
        else:
11527 
          iprot.skip(ftype)
2783 chandransh 11528 
      elif fid == 3:
11529 
        if ftype == TType.I64:
3064 chandransh 11530 
          self.to_date = iprot.readI64();
2783 chandransh 11531 
        else:
11532 
          iprot.skip(ftype)
11533 
      elif fid == 4:
3064 chandransh 11534 
        if ftype == TType.LIST:
11535 
          self.statuses = []
6188 rajveer 11536 
          (_etype193, _size190) = iprot.readListBegin()
11537 
          for _i194 in xrange(_size190):
11538 
            _elem195 = iprot.readI32();
11539 
            self.statuses.append(_elem195)
3064 chandransh 11540 
          iprot.readListEnd()
2783 chandransh 11541 
        else:
11542 
          iprot.skip(ftype)
1149 chandransh 11543 
      else:
11544 
        iprot.skip(ftype)
11545 
      iprot.readFieldEnd()
11546 
    iprot.readStructEnd()
11547 
 
11548 
  def write(self, oprot):
11549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11551 
      return
3064 chandransh 11552 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11553 
    if self.customerId is not None:
3064 chandransh 11554 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11555 
      oprot.writeI64(self.customerId)
1149 chandransh 11556 
      oprot.writeFieldEnd()
3431 rajveer 11557 
    if self.from_date is not None:
3064 chandransh 11558 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11559 
      oprot.writeI64(self.from_date)
1149 chandransh 11560 
      oprot.writeFieldEnd()
3431 rajveer 11561 
    if self.to_date is not None:
3064 chandransh 11562 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11563 
      oprot.writeI64(self.to_date)
2783 chandransh 11564 
      oprot.writeFieldEnd()
3431 rajveer 11565 
    if self.statuses is not None:
3064 chandransh 11566 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11567 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11568 
      for iter196 in self.statuses:
11569 
        oprot.writeI32(iter196)
3064 chandransh 11570 
      oprot.writeListEnd()
2783 chandransh 11571 
      oprot.writeFieldEnd()
1149 chandransh 11572 
    oprot.writeFieldStop()
11573 
    oprot.writeStructEnd()
11574 
 
3431 rajveer 11575 
  def validate(self):
11576 
    return
11577 
 
11578 
 
1149 chandransh 11579 
  def __repr__(self):
11580 
    L = ['%s=%r' % (key, value)
11581 
      for key, value in self.__dict__.iteritems()]
11582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11583 
 
11584 
  def __eq__(self, other):
11585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11586 
 
11587 
  def __ne__(self, other):
11588 
    return not (self == other)
11589 
 
3064 chandransh 11590 
class getOrdersForCustomer_result:
1149 chandransh 11591 
  """
11592 
  Attributes:
11593 
   - success
11594 
   - ex
11595 
  """
11596 
 
11597 
  thrift_spec = (
3064 chandransh 11598 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11599 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11600 
  )
11601 
 
11602 
  def __init__(self, success=None, ex=None,):
11603 
    self.success = success
11604 
    self.ex = ex
11605 
 
11606 
  def read(self, iprot):
11607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11609 
      return
11610 
    iprot.readStructBegin()
11611 
    while True:
11612 
      (fname, ftype, fid) = iprot.readFieldBegin()
11613 
      if ftype == TType.STOP:
11614 
        break
11615 
      if fid == 0:
3064 chandransh 11616 
        if ftype == TType.LIST:
11617 
          self.success = []
6188 rajveer 11618 
          (_etype200, _size197) = iprot.readListBegin()
11619 
          for _i201 in xrange(_size197):
11620 
            _elem202 = Order()
11621 
            _elem202.read(iprot)
11622 
            self.success.append(_elem202)
3064 chandransh 11623 
          iprot.readListEnd()
1149 chandransh 11624 
        else:
11625 
          iprot.skip(ftype)
11626 
      elif fid == 1:
11627 
        if ftype == TType.STRUCT:
11628 
          self.ex = TransactionServiceException()
11629 
          self.ex.read(iprot)
11630 
        else:
11631 
          iprot.skip(ftype)
11632 
      else:
11633 
        iprot.skip(ftype)
11634 
      iprot.readFieldEnd()
11635 
    iprot.readStructEnd()
11636 
 
11637 
  def write(self, oprot):
11638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11640 
      return
3064 chandransh 11641 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11642 
    if self.success is not None:
3064 chandransh 11643 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11644 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11645 
      for iter203 in self.success:
11646 
        iter203.write(oprot)
3064 chandransh 11647 
      oprot.writeListEnd()
1149 chandransh 11648 
      oprot.writeFieldEnd()
3431 rajveer 11649 
    if self.ex is not None:
1149 chandransh 11650 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11651 
      self.ex.write(oprot)
11652 
      oprot.writeFieldEnd()
11653 
    oprot.writeFieldStop()
11654 
    oprot.writeStructEnd()
11655 
 
3431 rajveer 11656 
  def validate(self):
11657 
    return
11658 
 
11659 
 
1149 chandransh 11660 
  def __repr__(self):
11661 
    L = ['%s=%r' % (key, value)
11662 
      for key, value in self.__dict__.iteritems()]
11663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11664 
 
11665 
  def __eq__(self, other):
11666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11667 
 
11668 
  def __ne__(self, other):
11669 
    return not (self == other)
11670 
 
3064 chandransh 11671 
class createOrder_args:
921 rajveer 11672 
  """
11673 
  Attributes:
3064 chandransh 11674 
   - order
921 rajveer 11675 
  """
11676 
 
11677 
  thrift_spec = (
11678 
    None, # 0
3064 chandransh 11679 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11680 
  )
11681 
 
3064 chandransh 11682 
  def __init__(self, order=None,):
11683 
    self.order = order
921 rajveer 11684 
 
11685 
  def read(self, iprot):
11686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11688 
      return
11689 
    iprot.readStructBegin()
11690 
    while True:
11691 
      (fname, ftype, fid) = iprot.readFieldBegin()
11692 
      if ftype == TType.STOP:
11693 
        break
11694 
      if fid == 1:
3064 chandransh 11695 
        if ftype == TType.STRUCT:
11696 
          self.order = Order()
11697 
          self.order.read(iprot)
921 rajveer 11698 
        else:
11699 
          iprot.skip(ftype)
11700 
      else:
11701 
        iprot.skip(ftype)
11702 
      iprot.readFieldEnd()
11703 
    iprot.readStructEnd()
11704 
 
11705 
  def write(self, oprot):
11706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11708 
      return
3064 chandransh 11709 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11710 
    if self.order is not None:
3064 chandransh 11711 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11712 
      self.order.write(oprot)
921 rajveer 11713 
      oprot.writeFieldEnd()
11714 
    oprot.writeFieldStop()
11715 
    oprot.writeStructEnd()
11716 
 
3431 rajveer 11717 
  def validate(self):
11718 
    return
11719 
 
11720 
 
921 rajveer 11721 
  def __repr__(self):
11722 
    L = ['%s=%r' % (key, value)
11723 
      for key, value in self.__dict__.iteritems()]
11724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11725 
 
11726 
  def __eq__(self, other):
11727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11728 
 
11729 
  def __ne__(self, other):
11730 
    return not (self == other)
11731 
 
3064 chandransh 11732 
class createOrder_result:
921 rajveer 11733 
  """
11734 
  Attributes:
11735 
   - success
11736 
   - ex
11737 
  """
11738 
 
11739 
  thrift_spec = (
3064 chandransh 11740 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11742 
  )
11743 
 
11744 
  def __init__(self, success=None, ex=None,):
11745 
    self.success = success
11746 
    self.ex = ex
11747 
 
11748 
  def read(self, iprot):
11749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11751 
      return
11752 
    iprot.readStructBegin()
11753 
    while True:
11754 
      (fname, ftype, fid) = iprot.readFieldBegin()
11755 
      if ftype == TType.STOP:
11756 
        break
11757 
      if fid == 0:
3064 chandransh 11758 
        if ftype == TType.I64:
11759 
          self.success = iprot.readI64();
921 rajveer 11760 
        else:
11761 
          iprot.skip(ftype)
11762 
      elif fid == 1:
11763 
        if ftype == TType.STRUCT:
11764 
          self.ex = TransactionServiceException()
11765 
          self.ex.read(iprot)
11766 
        else:
11767 
          iprot.skip(ftype)
11768 
      else:
11769 
        iprot.skip(ftype)
11770 
      iprot.readFieldEnd()
11771 
    iprot.readStructEnd()
11772 
 
11773 
  def write(self, oprot):
11774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11776 
      return
3064 chandransh 11777 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11778 
    if self.success is not None:
3064 chandransh 11779 
      oprot.writeFieldBegin('success', TType.I64, 0)
11780 
      oprot.writeI64(self.success)
921 rajveer 11781 
      oprot.writeFieldEnd()
3431 rajveer 11782 
    if self.ex is not None:
921 rajveer 11783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11784 
      self.ex.write(oprot)
11785 
      oprot.writeFieldEnd()
11786 
    oprot.writeFieldStop()
11787 
    oprot.writeStructEnd()
11788 
 
3431 rajveer 11789 
  def validate(self):
11790 
    return
11791 
 
11792 
 
921 rajveer 11793 
  def __repr__(self):
11794 
    L = ['%s=%r' % (key, value)
11795 
      for key, value in self.__dict__.iteritems()]
11796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11797 
 
11798 
  def __eq__(self, other):
11799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11800 
 
11801 
  def __ne__(self, other):
11802 
    return not (self == other)
11803 
 
3064 chandransh 11804 
class getOrder_args:
921 rajveer 11805 
  """
11806 
  Attributes:
3064 chandransh 11807 
   - id
921 rajveer 11808 
  """
11809 
 
11810 
  thrift_spec = (
11811 
    None, # 0
3064 chandransh 11812 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11813 
  )
11814 
 
3064 chandransh 11815 
  def __init__(self, id=None,):
11816 
    self.id = id
921 rajveer 11817 
 
11818 
  def read(self, iprot):
11819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11821 
      return
11822 
    iprot.readStructBegin()
11823 
    while True:
11824 
      (fname, ftype, fid) = iprot.readFieldBegin()
11825 
      if ftype == TType.STOP:
11826 
        break
11827 
      if fid == 1:
11828 
        if ftype == TType.I64:
3064 chandransh 11829 
          self.id = iprot.readI64();
921 rajveer 11830 
        else:
11831 
          iprot.skip(ftype)
11832 
      else:
11833 
        iprot.skip(ftype)
11834 
      iprot.readFieldEnd()
11835 
    iprot.readStructEnd()
11836 
 
11837 
  def write(self, oprot):
11838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11840 
      return
3064 chandransh 11841 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11842 
    if self.id is not None:
3064 chandransh 11843 
      oprot.writeFieldBegin('id', TType.I64, 1)
11844 
      oprot.writeI64(self.id)
921 rajveer 11845 
      oprot.writeFieldEnd()
11846 
    oprot.writeFieldStop()
11847 
    oprot.writeStructEnd()
11848 
 
3431 rajveer 11849 
  def validate(self):
11850 
    return
11851 
 
11852 
 
921 rajveer 11853 
  def __repr__(self):
11854 
    L = ['%s=%r' % (key, value)
11855 
      for key, value in self.__dict__.iteritems()]
11856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11857 
 
11858 
  def __eq__(self, other):
11859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11860 
 
11861 
  def __ne__(self, other):
11862 
    return not (self == other)
11863 
 
3064 chandransh 11864 
class getOrder_result:
921 rajveer 11865 
  """
11866 
  Attributes:
11867 
   - success
11868 
   - ex
11869 
  """
11870 
 
11871 
  thrift_spec = (
3064 chandransh 11872 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11873 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11874 
  )
11875 
 
11876 
  def __init__(self, success=None, ex=None,):
11877 
    self.success = success
11878 
    self.ex = ex
11879 
 
11880 
  def read(self, iprot):
11881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11883 
      return
11884 
    iprot.readStructBegin()
11885 
    while True:
11886 
      (fname, ftype, fid) = iprot.readFieldBegin()
11887 
      if ftype == TType.STOP:
11888 
        break
11889 
      if fid == 0:
3064 chandransh 11890 
        if ftype == TType.STRUCT:
11891 
          self.success = Order()
11892 
          self.success.read(iprot)
921 rajveer 11893 
        else:
11894 
          iprot.skip(ftype)
11895 
      elif fid == 1:
11896 
        if ftype == TType.STRUCT:
11897 
          self.ex = TransactionServiceException()
11898 
          self.ex.read(iprot)
11899 
        else:
11900 
          iprot.skip(ftype)
11901 
      else:
11902 
        iprot.skip(ftype)
11903 
      iprot.readFieldEnd()
11904 
    iprot.readStructEnd()
11905 
 
11906 
  def write(self, oprot):
11907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11909 
      return
3064 chandransh 11910 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11911 
    if self.success is not None:
3064 chandransh 11912 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11913 
      self.success.write(oprot)
921 rajveer 11914 
      oprot.writeFieldEnd()
3431 rajveer 11915 
    if self.ex is not None:
921 rajveer 11916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11917 
      self.ex.write(oprot)
11918 
      oprot.writeFieldEnd()
11919 
    oprot.writeFieldStop()
11920 
    oprot.writeStructEnd()
11921 
 
3431 rajveer 11922 
  def validate(self):
11923 
    return
11924 
 
11925 
 
921 rajveer 11926 
  def __repr__(self):
11927 
    L = ['%s=%r' % (key, value)
11928 
      for key, value in self.__dict__.iteritems()]
11929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11930 
 
11931 
  def __eq__(self, other):
11932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11933 
 
11934 
  def __ne__(self, other):
11935 
    return not (self == other)
11936 
 
3064 chandransh 11937 
class getLineItemsForOrder_args:
94 ashish 11938 
  """
11939 
  Attributes:
3064 chandransh 11940 
   - orderId
94 ashish 11941 
  """
11942 
 
11943 
  thrift_spec = (
11944 
    None, # 0
3064 chandransh 11945 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11946 
  )
11947 
 
3064 chandransh 11948 
  def __init__(self, orderId=None,):
11949 
    self.orderId = orderId
94 ashish 11950 
 
11951 
  def read(self, iprot):
11952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11954 
      return
11955 
    iprot.readStructBegin()
11956 
    while True:
11957 
      (fname, ftype, fid) = iprot.readFieldBegin()
11958 
      if ftype == TType.STOP:
11959 
        break
11960 
      if fid == 1:
11961 
        if ftype == TType.I64:
3064 chandransh 11962 
          self.orderId = iprot.readI64();
94 ashish 11963 
        else:
11964 
          iprot.skip(ftype)
11965 
      else:
11966 
        iprot.skip(ftype)
11967 
      iprot.readFieldEnd()
11968 
    iprot.readStructEnd()
11969 
 
11970 
  def write(self, oprot):
11971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11973 
      return
3064 chandransh 11974 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11975 
    if self.orderId is not None:
3064 chandransh 11976 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11977 
      oprot.writeI64(self.orderId)
94 ashish 11978 
      oprot.writeFieldEnd()
11979 
    oprot.writeFieldStop()
11980 
    oprot.writeStructEnd()
11981 
 
3431 rajveer 11982 
  def validate(self):
11983 
    return
11984 
 
11985 
 
94 ashish 11986 
  def __repr__(self):
11987 
    L = ['%s=%r' % (key, value)
11988 
      for key, value in self.__dict__.iteritems()]
11989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11990 
 
11991 
  def __eq__(self, other):
11992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11993 
 
11994 
  def __ne__(self, other):
11995 
    return not (self == other)
11996 
 
3064 chandransh 11997 
class getLineItemsForOrder_result:
94 ashish 11998 
  """
11999 
  Attributes:
12000 
   - success
12001 
   - ex
12002 
  """
12003 
 
12004 
  thrift_spec = (
3064 chandransh 12005 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12007 
  )
12008 
 
12009 
  def __init__(self, success=None, ex=None,):
12010 
    self.success = success
12011 
    self.ex = ex
12012 
 
12013 
  def read(self, iprot):
12014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12016 
      return
12017 
    iprot.readStructBegin()
12018 
    while True:
12019 
      (fname, ftype, fid) = iprot.readFieldBegin()
12020 
      if ftype == TType.STOP:
12021 
        break
12022 
      if fid == 0:
483 rajveer 12023 
        if ftype == TType.LIST:
12024 
          self.success = []
6188 rajveer 12025 
          (_etype207, _size204) = iprot.readListBegin()
12026 
          for _i208 in xrange(_size204):
12027 
            _elem209 = LineItem()
12028 
            _elem209.read(iprot)
12029 
            self.success.append(_elem209)
483 rajveer 12030 
          iprot.readListEnd()
94 ashish 12031 
        else:
12032 
          iprot.skip(ftype)
12033 
      elif fid == 1:
12034 
        if ftype == TType.STRUCT:
12035 
          self.ex = TransactionServiceException()
12036 
          self.ex.read(iprot)
12037 
        else:
12038 
          iprot.skip(ftype)
12039 
      else:
12040 
        iprot.skip(ftype)
12041 
      iprot.readFieldEnd()
12042 
    iprot.readStructEnd()
12043 
 
12044 
  def write(self, oprot):
12045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12047 
      return
3064 chandransh 12048 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12049 
    if self.success is not None:
483 rajveer 12050 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12051 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12052 
      for iter210 in self.success:
12053 
        iter210.write(oprot)
483 rajveer 12054 
      oprot.writeListEnd()
94 ashish 12055 
      oprot.writeFieldEnd()
3431 rajveer 12056 
    if self.ex is not None:
94 ashish 12057 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12058 
      self.ex.write(oprot)
12059 
      oprot.writeFieldEnd()
12060 
    oprot.writeFieldStop()
12061 
    oprot.writeStructEnd()
12062 
 
3431 rajveer 12063 
  def validate(self):
12064 
    return
12065 
 
12066 
 
94 ashish 12067 
  def __repr__(self):
12068 
    L = ['%s=%r' % (key, value)
12069 
      for key, value in self.__dict__.iteritems()]
12070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12071 
 
12072 
  def __eq__(self, other):
12073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12074 
 
12075 
  def __ne__(self, other):
12076 
    return not (self == other)
12077 
 
4999 phani.kuma 12078 
class getOrderList_args:
12079 
  """
12080 
  Attributes:
12081 
   - order_ids
12082 
  """
12083 
 
12084 
  thrift_spec = (
12085 
    None, # 0
12086 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12087 
  )
12088 
 
12089 
  def __init__(self, order_ids=None,):
12090 
    self.order_ids = order_ids
12091 
 
12092 
  def read(self, iprot):
12093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12095 
      return
12096 
    iprot.readStructBegin()
12097 
    while True:
12098 
      (fname, ftype, fid) = iprot.readFieldBegin()
12099 
      if ftype == TType.STOP:
12100 
        break
12101 
      if fid == 1:
12102 
        if ftype == TType.LIST:
12103 
          self.order_ids = []
6188 rajveer 12104 
          (_etype214, _size211) = iprot.readListBegin()
12105 
          for _i215 in xrange(_size211):
12106 
            _elem216 = iprot.readI64();
12107 
            self.order_ids.append(_elem216)
4999 phani.kuma 12108 
          iprot.readListEnd()
12109 
        else:
12110 
          iprot.skip(ftype)
12111 
      else:
12112 
        iprot.skip(ftype)
12113 
      iprot.readFieldEnd()
12114 
    iprot.readStructEnd()
12115 
 
12116 
  def write(self, oprot):
12117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12119 
      return
12120 
    oprot.writeStructBegin('getOrderList_args')
12121 
    if self.order_ids is not None:
12122 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12123 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12124 
      for iter217 in self.order_ids:
12125 
        oprot.writeI64(iter217)
4999 phani.kuma 12126 
      oprot.writeListEnd()
12127 
      oprot.writeFieldEnd()
12128 
    oprot.writeFieldStop()
12129 
    oprot.writeStructEnd()
12130 
 
12131 
  def validate(self):
12132 
    return
12133 
 
12134 
 
12135 
  def __repr__(self):
12136 
    L = ['%s=%r' % (key, value)
12137 
      for key, value in self.__dict__.iteritems()]
12138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12139 
 
12140 
  def __eq__(self, other):
12141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12142 
 
12143 
  def __ne__(self, other):
12144 
    return not (self == other)
12145 
 
12146 
class getOrderList_result:
12147 
  """
12148 
  Attributes:
12149 
   - success
12150 
  """
12151 
 
12152 
  thrift_spec = (
12153 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12154 
  )
12155 
 
12156 
  def __init__(self, success=None,):
12157 
    self.success = success
12158 
 
12159 
  def read(self, iprot):
12160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12162 
      return
12163 
    iprot.readStructBegin()
12164 
    while True:
12165 
      (fname, ftype, fid) = iprot.readFieldBegin()
12166 
      if ftype == TType.STOP:
12167 
        break
12168 
      if fid == 0:
12169 
        if ftype == TType.LIST:
12170 
          self.success = []
6188 rajveer 12171 
          (_etype221, _size218) = iprot.readListBegin()
12172 
          for _i222 in xrange(_size218):
12173 
            _elem223 = Order()
12174 
            _elem223.read(iprot)
12175 
            self.success.append(_elem223)
4999 phani.kuma 12176 
          iprot.readListEnd()
12177 
        else:
12178 
          iprot.skip(ftype)
12179 
      else:
12180 
        iprot.skip(ftype)
12181 
      iprot.readFieldEnd()
12182 
    iprot.readStructEnd()
12183 
 
12184 
  def write(self, oprot):
12185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12187 
      return
12188 
    oprot.writeStructBegin('getOrderList_result')
12189 
    if self.success is not None:
12190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12192 
      for iter224 in self.success:
12193 
        iter224.write(oprot)
4999 phani.kuma 12194 
      oprot.writeListEnd()
12195 
      oprot.writeFieldEnd()
12196 
    oprot.writeFieldStop()
12197 
    oprot.writeStructEnd()
12198 
 
12199 
  def validate(self):
12200 
    return
12201 
 
12202 
 
12203 
  def __repr__(self):
12204 
    L = ['%s=%r' % (key, value)
12205 
      for key, value in self.__dict__.iteritems()]
12206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12207 
 
12208 
  def __eq__(self, other):
12209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12210 
 
12211 
  def __ne__(self, other):
12212 
    return not (self == other)
12213 
 
5386 phani.kuma 12214 
class getOrderListForVendor_args:
12215 
  """
12216 
  Attributes:
12217 
   - order_ids
12218 
   - vendorId
12219 
  """
12220 
 
12221 
  thrift_spec = (
12222 
    None, # 0
12223 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12224 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12225 
  )
12226 
 
12227 
  def __init__(self, order_ids=None, vendorId=None,):
12228 
    self.order_ids = order_ids
12229 
    self.vendorId = vendorId
12230 
 
12231 
  def read(self, iprot):
12232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12234 
      return
12235 
    iprot.readStructBegin()
12236 
    while True:
12237 
      (fname, ftype, fid) = iprot.readFieldBegin()
12238 
      if ftype == TType.STOP:
12239 
        break
12240 
      if fid == 1:
12241 
        if ftype == TType.LIST:
12242 
          self.order_ids = []
6188 rajveer 12243 
          (_etype228, _size225) = iprot.readListBegin()
12244 
          for _i229 in xrange(_size225):
12245 
            _elem230 = iprot.readI64();
12246 
            self.order_ids.append(_elem230)
5386 phani.kuma 12247 
          iprot.readListEnd()
12248 
        else:
12249 
          iprot.skip(ftype)
12250 
      elif fid == 2:
12251 
        if ftype == TType.I64:
12252 
          self.vendorId = iprot.readI64();
12253 
        else:
12254 
          iprot.skip(ftype)
12255 
      else:
12256 
        iprot.skip(ftype)
12257 
      iprot.readFieldEnd()
12258 
    iprot.readStructEnd()
12259 
 
12260 
  def write(self, oprot):
12261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12263 
      return
12264 
    oprot.writeStructBegin('getOrderListForVendor_args')
12265 
    if self.order_ids is not None:
12266 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12267 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12268 
      for iter231 in self.order_ids:
12269 
        oprot.writeI64(iter231)
5386 phani.kuma 12270 
      oprot.writeListEnd()
12271 
      oprot.writeFieldEnd()
12272 
    if self.vendorId is not None:
12273 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12274 
      oprot.writeI64(self.vendorId)
12275 
      oprot.writeFieldEnd()
12276 
    oprot.writeFieldStop()
12277 
    oprot.writeStructEnd()
12278 
 
12279 
  def validate(self):
12280 
    return
12281 
 
12282 
 
12283 
  def __repr__(self):
12284 
    L = ['%s=%r' % (key, value)
12285 
      for key, value in self.__dict__.iteritems()]
12286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12287 
 
12288 
  def __eq__(self, other):
12289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12290 
 
12291 
  def __ne__(self, other):
12292 
    return not (self == other)
12293 
 
12294 
class getOrderListForVendor_result:
12295 
  """
12296 
  Attributes:
12297 
   - success
12298 
  """
12299 
 
12300 
  thrift_spec = (
12301 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12302 
  )
12303 
 
12304 
  def __init__(self, success=None,):
12305 
    self.success = success
12306 
 
12307 
  def read(self, iprot):
12308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12310 
      return
12311 
    iprot.readStructBegin()
12312 
    while True:
12313 
      (fname, ftype, fid) = iprot.readFieldBegin()
12314 
      if ftype == TType.STOP:
12315 
        break
12316 
      if fid == 0:
12317 
        if ftype == TType.LIST:
12318 
          self.success = []
6188 rajveer 12319 
          (_etype235, _size232) = iprot.readListBegin()
12320 
          for _i236 in xrange(_size232):
12321 
            _elem237 = Order()
12322 
            _elem237.read(iprot)
12323 
            self.success.append(_elem237)
5386 phani.kuma 12324 
          iprot.readListEnd()
12325 
        else:
12326 
          iprot.skip(ftype)
12327 
      else:
12328 
        iprot.skip(ftype)
12329 
      iprot.readFieldEnd()
12330 
    iprot.readStructEnd()
12331 
 
12332 
  def write(self, oprot):
12333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12335 
      return
12336 
    oprot.writeStructBegin('getOrderListForVendor_result')
12337 
    if self.success is not None:
12338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12339 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12340 
      for iter238 in self.success:
12341 
        iter238.write(oprot)
5386 phani.kuma 12342 
      oprot.writeListEnd()
12343 
      oprot.writeFieldEnd()
12344 
    oprot.writeFieldStop()
12345 
    oprot.writeStructEnd()
12346 
 
12347 
  def validate(self):
12348 
    return
12349 
 
12350 
 
12351 
  def __repr__(self):
12352 
    L = ['%s=%r' % (key, value)
12353 
      for key, value in self.__dict__.iteritems()]
12354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12355 
 
12356 
  def __eq__(self, other):
12357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12358 
 
12359 
  def __ne__(self, other):
12360 
    return not (self == other)
12361 
 
3064 chandransh 12362 
class getOrderForCustomer_args:
94 ashish 12363 
  """
12364 
  Attributes:
3064 chandransh 12365 
   - orderId
483 rajveer 12366 
   - customerId
94 ashish 12367 
  """
12368 
 
12369 
  thrift_spec = (
12370 
    None, # 0
3064 chandransh 12371 
    (1, TType.I64, 'orderId', None, None, ), # 1
12372 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12373 
  )
12374 
 
3064 chandransh 12375 
  def __init__(self, orderId=None, customerId=None,):
12376 
    self.orderId = orderId
483 rajveer 12377 
    self.customerId = customerId
94 ashish 12378 
 
12379 
  def read(self, iprot):
12380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12382 
      return
12383 
    iprot.readStructBegin()
12384 
    while True:
12385 
      (fname, ftype, fid) = iprot.readFieldBegin()
12386 
      if ftype == TType.STOP:
12387 
        break
12388 
      if fid == 1:
12389 
        if ftype == TType.I64:
3064 chandransh 12390 
          self.orderId = iprot.readI64();
94 ashish 12391 
        else:
12392 
          iprot.skip(ftype)
12393 
      elif fid == 2:
12394 
        if ftype == TType.I64:
3064 chandransh 12395 
          self.customerId = iprot.readI64();
94 ashish 12396 
        else:
12397 
          iprot.skip(ftype)
12398 
      else:
12399 
        iprot.skip(ftype)
12400 
      iprot.readFieldEnd()
12401 
    iprot.readStructEnd()
12402 
 
12403 
  def write(self, oprot):
12404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12406 
      return
3064 chandransh 12407 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12408 
    if self.orderId is not None:
3064 chandransh 12409 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12410 
      oprot.writeI64(self.orderId)
12411 
      oprot.writeFieldEnd()
3431 rajveer 12412 
    if self.customerId is not None:
3064 chandransh 12413 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12414 
      oprot.writeI64(self.customerId)
94 ashish 12415 
      oprot.writeFieldEnd()
12416 
    oprot.writeFieldStop()
12417 
    oprot.writeStructEnd()
12418 
 
3431 rajveer 12419 
  def validate(self):
12420 
    return
12421 
 
12422 
 
94 ashish 12423 
  def __repr__(self):
12424 
    L = ['%s=%r' % (key, value)
12425 
      for key, value in self.__dict__.iteritems()]
12426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12427 
 
12428 
  def __eq__(self, other):
12429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12430 
 
12431 
  def __ne__(self, other):
12432 
    return not (self == other)
12433 
 
3064 chandransh 12434 
class getOrderForCustomer_result:
94 ashish 12435 
  """
12436 
  Attributes:
12437 
   - success
12438 
   - ex
12439 
  """
12440 
 
12441 
  thrift_spec = (
3064 chandransh 12442 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12444 
  )
12445 
 
12446 
  def __init__(self, success=None, ex=None,):
12447 
    self.success = success
12448 
    self.ex = ex
12449 
 
12450 
  def read(self, iprot):
12451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12453 
      return
12454 
    iprot.readStructBegin()
12455 
    while True:
12456 
      (fname, ftype, fid) = iprot.readFieldBegin()
12457 
      if ftype == TType.STOP:
12458 
        break
12459 
      if fid == 0:
3064 chandransh 12460 
        if ftype == TType.STRUCT:
12461 
          self.success = Order()
12462 
          self.success.read(iprot)
94 ashish 12463 
        else:
12464 
          iprot.skip(ftype)
12465 
      elif fid == 1:
12466 
        if ftype == TType.STRUCT:
12467 
          self.ex = TransactionServiceException()
12468 
          self.ex.read(iprot)
12469 
        else:
12470 
          iprot.skip(ftype)
12471 
      else:
12472 
        iprot.skip(ftype)
12473 
      iprot.readFieldEnd()
12474 
    iprot.readStructEnd()
12475 
 
12476 
  def write(self, oprot):
12477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12479 
      return
3064 chandransh 12480 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12481 
    if self.success is not None:
3064 chandransh 12482 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12483 
      self.success.write(oprot)
94 ashish 12484 
      oprot.writeFieldEnd()
3431 rajveer 12485 
    if self.ex is not None:
94 ashish 12486 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12487 
      self.ex.write(oprot)
12488 
      oprot.writeFieldEnd()
12489 
    oprot.writeFieldStop()
12490 
    oprot.writeStructEnd()
12491 
 
3431 rajveer 12492 
  def validate(self):
12493 
    return
12494 
 
12495 
 
94 ashish 12496 
  def __repr__(self):
12497 
    L = ['%s=%r' % (key, value)
12498 
      for key, value in self.__dict__.iteritems()]
12499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12500 
 
12501 
  def __eq__(self, other):
12502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12503 
 
12504 
  def __ne__(self, other):
12505 
    return not (self == other)
12506 
 
3064 chandransh 12507 
class getAlerts_args:
94 ashish 12508 
  """
12509 
  Attributes:
4394 rajveer 12510 
   - type
4444 rajveer 12511 
   - warehouseId
4394 rajveer 12512 
   - status
12513 
   - timestamp
94 ashish 12514 
  """
12515 
 
12516 
  thrift_spec = (
12517 
    None, # 0
4394 rajveer 12518 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12519 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12520 
    (3, TType.I64, 'status', None, None, ), # 3
12521 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12522 
  )
12523 
 
4444 rajveer 12524 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12525 
    self.type = type
4444 rajveer 12526 
    self.warehouseId = warehouseId
4394 rajveer 12527 
    self.status = status
12528 
    self.timestamp = timestamp
94 ashish 12529 
 
12530 
  def read(self, iprot):
12531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12533 
      return
12534 
    iprot.readStructBegin()
12535 
    while True:
12536 
      (fname, ftype, fid) = iprot.readFieldBegin()
12537 
      if ftype == TType.STOP:
12538 
        break
12539 
      if fid == 1:
3064 chandransh 12540 
        if ftype == TType.I64:
4394 rajveer 12541 
          self.type = iprot.readI64();
94 ashish 12542 
        else:
12543 
          iprot.skip(ftype)
3064 chandransh 12544 
      elif fid == 2:
4394 rajveer 12545 
        if ftype == TType.I64:
4444 rajveer 12546 
          self.warehouseId = iprot.readI64();
3064 chandransh 12547 
        else:
12548 
          iprot.skip(ftype)
4394 rajveer 12549 
      elif fid == 3:
12550 
        if ftype == TType.I64:
4444 rajveer 12551 
          self.status = iprot.readI64();
12552 
        else:
12553 
          iprot.skip(ftype)
12554 
      elif fid == 4:
12555 
        if ftype == TType.I64:
4394 rajveer 12556 
          self.timestamp = iprot.readI64();
12557 
        else:
12558 
          iprot.skip(ftype)
94 ashish 12559 
      else:
12560 
        iprot.skip(ftype)
12561 
      iprot.readFieldEnd()
12562 
    iprot.readStructEnd()
12563 
 
12564 
  def write(self, oprot):
12565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12567 
      return
3064 chandransh 12568 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12569 
    if self.type is not None:
12570 
      oprot.writeFieldBegin('type', TType.I64, 1)
12571 
      oprot.writeI64(self.type)
94 ashish 12572 
      oprot.writeFieldEnd()
4444 rajveer 12573 
    if self.warehouseId is not None:
12574 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12575 
      oprot.writeI64(self.warehouseId)
12576 
      oprot.writeFieldEnd()
4394 rajveer 12577 
    if self.status is not None:
4444 rajveer 12578 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12579 
      oprot.writeI64(self.status)
3064 chandransh 12580 
      oprot.writeFieldEnd()
4394 rajveer 12581 
    if self.timestamp is not None:
4444 rajveer 12582 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12583 
      oprot.writeI64(self.timestamp)
12584 
      oprot.writeFieldEnd()
94 ashish 12585 
    oprot.writeFieldStop()
12586 
    oprot.writeStructEnd()
12587 
 
3431 rajveer 12588 
  def validate(self):
12589 
    return
12590 
 
12591 
 
94 ashish 12592 
  def __repr__(self):
12593 
    L = ['%s=%r' % (key, value)
12594 
      for key, value in self.__dict__.iteritems()]
12595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12596 
 
12597 
  def __eq__(self, other):
12598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12599 
 
12600 
  def __ne__(self, other):
12601 
    return not (self == other)
12602 
 
3064 chandransh 12603 
class getAlerts_result:
94 ashish 12604 
  """
12605 
  Attributes:
12606 
   - success
12607 
  """
12608 
 
12609 
  thrift_spec = (
3064 chandransh 12610 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12611 
  )
12612 
 
3064 chandransh 12613 
  def __init__(self, success=None,):
94 ashish 12614 
    self.success = success
12615 
 
12616 
  def read(self, iprot):
12617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12619 
      return
12620 
    iprot.readStructBegin()
12621 
    while True:
12622 
      (fname, ftype, fid) = iprot.readFieldBegin()
12623 
      if ftype == TType.STOP:
12624 
        break
12625 
      if fid == 0:
3064 chandransh 12626 
        if ftype == TType.LIST:
12627 
          self.success = []
6188 rajveer 12628 
          (_etype242, _size239) = iprot.readListBegin()
12629 
          for _i243 in xrange(_size239):
12630 
            _elem244 = Alert()
12631 
            _elem244.read(iprot)
12632 
            self.success.append(_elem244)
3064 chandransh 12633 
          iprot.readListEnd()
94 ashish 12634 
        else:
12635 
          iprot.skip(ftype)
12636 
      else:
12637 
        iprot.skip(ftype)
12638 
      iprot.readFieldEnd()
12639 
    iprot.readStructEnd()
12640 
 
12641 
  def write(self, oprot):
12642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12644 
      return
3064 chandransh 12645 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12646 
    if self.success is not None:
3064 chandransh 12647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12649 
      for iter245 in self.success:
12650 
        iter245.write(oprot)
3064 chandransh 12651 
      oprot.writeListEnd()
94 ashish 12652 
      oprot.writeFieldEnd()
12653 
    oprot.writeFieldStop()
12654 
    oprot.writeStructEnd()
12655 
 
3431 rajveer 12656 
  def validate(self):
12657 
    return
12658 
 
12659 
 
94 ashish 12660 
  def __repr__(self):
12661 
    L = ['%s=%r' % (key, value)
12662 
      for key, value in self.__dict__.iteritems()]
12663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12664 
 
12665 
  def __eq__(self, other):
12666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12667 
 
12668 
  def __ne__(self, other):
12669 
    return not (self == other)
12670 
 
4394 rajveer 12671 
class addAlert_args:
94 ashish 12672 
  """
12673 
  Attributes:
3064 chandransh 12674 
   - type
4444 rajveer 12675 
   - warehouseId
4394 rajveer 12676 
   - description
94 ashish 12677 
  """
12678 
 
12679 
  thrift_spec = (
12680 
    None, # 0
4394 rajveer 12681 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12682 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12683 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12684 
  )
12685 
 
4444 rajveer 12686 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12687 
    self.type = type
4444 rajveer 12688 
    self.warehouseId = warehouseId
4394 rajveer 12689 
    self.description = description
94 ashish 12690 
 
12691 
  def read(self, iprot):
12692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12694 
      return
12695 
    iprot.readStructBegin()
12696 
    while True:
12697 
      (fname, ftype, fid) = iprot.readFieldBegin()
12698 
      if ftype == TType.STOP:
12699 
        break
12700 
      if fid == 1:
12701 
        if ftype == TType.I64:
4394 rajveer 12702 
          self.type = iprot.readI64();
94 ashish 12703 
        else:
12704 
          iprot.skip(ftype)
3064 chandransh 12705 
      elif fid == 2:
4444 rajveer 12706 
        if ftype == TType.I64:
12707 
          self.warehouseId = iprot.readI64();
12708 
        else:
12709 
          iprot.skip(ftype)
12710 
      elif fid == 3:
3064 chandransh 12711 
        if ftype == TType.STRING:
4394 rajveer 12712 
          self.description = iprot.readString();
3064 chandransh 12713 
        else:
12714 
          iprot.skip(ftype)
94 ashish 12715 
      else:
12716 
        iprot.skip(ftype)
12717 
      iprot.readFieldEnd()
12718 
    iprot.readStructEnd()
12719 
 
12720 
  def write(self, oprot):
12721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12723 
      return
4394 rajveer 12724 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12725 
    if self.type is not None:
4394 rajveer 12726 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12727 
      oprot.writeI64(self.type)
12728 
      oprot.writeFieldEnd()
4444 rajveer 12729 
    if self.warehouseId is not None:
12730 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12731 
      oprot.writeI64(self.warehouseId)
12732 
      oprot.writeFieldEnd()
4394 rajveer 12733 
    if self.description is not None:
4444 rajveer 12734 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12735 
      oprot.writeString(self.description)
3064 chandransh 12736 
      oprot.writeFieldEnd()
94 ashish 12737 
    oprot.writeFieldStop()
12738 
    oprot.writeStructEnd()
12739 
 
3431 rajveer 12740 
  def validate(self):
12741 
    return
12742 
 
12743 
 
94 ashish 12744 
  def __repr__(self):
12745 
    L = ['%s=%r' % (key, value)
12746 
      for key, value in self.__dict__.iteritems()]
12747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12748 
 
12749 
  def __eq__(self, other):
12750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12751 
 
12752 
  def __ne__(self, other):
12753 
    return not (self == other)
12754 
 
4394 rajveer 12755 
class addAlert_result:
3064 chandransh 12756 
 
12757 
  thrift_spec = (
12758 
  )
12759 
 
12760 
  def read(self, iprot):
12761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12763 
      return
12764 
    iprot.readStructBegin()
12765 
    while True:
12766 
      (fname, ftype, fid) = iprot.readFieldBegin()
12767 
      if ftype == TType.STOP:
12768 
        break
12769 
      else:
12770 
        iprot.skip(ftype)
12771 
      iprot.readFieldEnd()
12772 
    iprot.readStructEnd()
12773 
 
12774 
  def write(self, oprot):
12775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12777 
      return
4394 rajveer 12778 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12779 
    oprot.writeFieldStop()
12780 
    oprot.writeStructEnd()
12781 
 
3431 rajveer 12782 
  def validate(self):
12783 
    return
12784 
 
12785 
 
3064 chandransh 12786 
  def __repr__(self):
12787 
    L = ['%s=%r' % (key, value)
12788 
      for key, value in self.__dict__.iteritems()]
12789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12790 
 
12791 
  def __eq__(self, other):
12792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12793 
 
12794 
  def __ne__(self, other):
12795 
    return not (self == other)
12796 
 
4444 rajveer 12797 
class markAlertsAsSeen_args:
12798 
  """
12799 
  Attributes:
12800 
   - warehouseId
12801 
  """
12802 
 
12803 
  thrift_spec = (
12804 
    None, # 0
12805 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12806 
  )
12807 
 
12808 
  def __init__(self, warehouseId=None,):
12809 
    self.warehouseId = warehouseId
12810 
 
12811 
  def read(self, iprot):
12812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12814 
      return
12815 
    iprot.readStructBegin()
12816 
    while True:
12817 
      (fname, ftype, fid) = iprot.readFieldBegin()
12818 
      if ftype == TType.STOP:
12819 
        break
12820 
      if fid == 1:
12821 
        if ftype == TType.I64:
12822 
          self.warehouseId = iprot.readI64();
12823 
        else:
12824 
          iprot.skip(ftype)
12825 
      else:
12826 
        iprot.skip(ftype)
12827 
      iprot.readFieldEnd()
12828 
    iprot.readStructEnd()
12829 
 
12830 
  def write(self, oprot):
12831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12833 
      return
12834 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12835 
    if self.warehouseId is not None:
12836 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12837 
      oprot.writeI64(self.warehouseId)
12838 
      oprot.writeFieldEnd()
12839 
    oprot.writeFieldStop()
12840 
    oprot.writeStructEnd()
12841 
 
12842 
  def validate(self):
12843 
    return
12844 
 
12845 
 
12846 
  def __repr__(self):
12847 
    L = ['%s=%r' % (key, value)
12848 
      for key, value in self.__dict__.iteritems()]
12849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12850 
 
12851 
  def __eq__(self, other):
12852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12853 
 
12854 
  def __ne__(self, other):
12855 
    return not (self == other)
12856 
 
12857 
class markAlertsAsSeen_result:
12858 
 
12859 
  thrift_spec = (
12860 
  )
12861 
 
12862 
  def read(self, iprot):
12863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12865 
      return
12866 
    iprot.readStructBegin()
12867 
    while True:
12868 
      (fname, ftype, fid) = iprot.readFieldBegin()
12869 
      if ftype == TType.STOP:
12870 
        break
12871 
      else:
12872 
        iprot.skip(ftype)
12873 
      iprot.readFieldEnd()
12874 
    iprot.readStructEnd()
12875 
 
12876 
  def write(self, oprot):
12877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12879 
      return
12880 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12881 
    oprot.writeFieldStop()
12882 
    oprot.writeStructEnd()
12883 
 
12884 
  def validate(self):
12885 
    return
12886 
 
12887 
 
12888 
  def __repr__(self):
12889 
    L = ['%s=%r' % (key, value)
12890 
      for key, value in self.__dict__.iteritems()]
12891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12892 
 
12893 
  def __eq__(self, other):
12894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12895 
 
12896 
  def __ne__(self, other):
12897 
    return not (self == other)
12898 
 
3064 chandransh 12899 
class getValidOrderCount_args:
12900 
 
12901 
  thrift_spec = (
12902 
  )
12903 
 
12904 
  def read(self, iprot):
12905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12907 
      return
12908 
    iprot.readStructBegin()
12909 
    while True:
12910 
      (fname, ftype, fid) = iprot.readFieldBegin()
12911 
      if ftype == TType.STOP:
12912 
        break
12913 
      else:
12914 
        iprot.skip(ftype)
12915 
      iprot.readFieldEnd()
12916 
    iprot.readStructEnd()
12917 
 
12918 
  def write(self, oprot):
12919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12921 
      return
12922 
    oprot.writeStructBegin('getValidOrderCount_args')
12923 
    oprot.writeFieldStop()
12924 
    oprot.writeStructEnd()
12925 
 
3431 rajveer 12926 
  def validate(self):
12927 
    return
12928 
 
12929 
 
3064 chandransh 12930 
  def __repr__(self):
12931 
    L = ['%s=%r' % (key, value)
12932 
      for key, value in self.__dict__.iteritems()]
12933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12934 
 
12935 
  def __eq__(self, other):
12936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12937 
 
12938 
  def __ne__(self, other):
12939 
    return not (self == other)
12940 
 
12941 
class getValidOrderCount_result:
94 ashish 12942 
  """
12943 
  Attributes:
12944 
   - success
12945 
  """
12946 
 
12947 
  thrift_spec = (
3064 chandransh 12948 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12949 
  )
12950 
 
3064 chandransh 12951 
  def __init__(self, success=None,):
94 ashish 12952 
    self.success = success
12953 
 
12954 
  def read(self, iprot):
12955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12957 
      return
12958 
    iprot.readStructBegin()
12959 
    while True:
12960 
      (fname, ftype, fid) = iprot.readFieldBegin()
12961 
      if ftype == TType.STOP:
12962 
        break
12963 
      if fid == 0:
3064 chandransh 12964 
        if ftype == TType.I64:
12965 
          self.success = iprot.readI64();
94 ashish 12966 
        else:
12967 
          iprot.skip(ftype)
12968 
      else:
12969 
        iprot.skip(ftype)
12970 
      iprot.readFieldEnd()
12971 
    iprot.readStructEnd()
12972 
 
12973 
  def write(self, oprot):
12974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12976 
      return
3064 chandransh 12977 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12978 
    if self.success is not None:
3064 chandransh 12979 
      oprot.writeFieldBegin('success', TType.I64, 0)
12980 
      oprot.writeI64(self.success)
94 ashish 12981 
      oprot.writeFieldEnd()
12982 
    oprot.writeFieldStop()
12983 
    oprot.writeStructEnd()
12984 
 
3431 rajveer 12985 
  def validate(self):
12986 
    return
12987 
 
12988 
 
94 ashish 12989 
  def __repr__(self):
12990 
    L = ['%s=%r' % (key, value)
12991 
      for key, value in self.__dict__.iteritems()]
12992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12993 
 
12994 
  def __eq__(self, other):
12995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12996 
 
12997 
  def __ne__(self, other):
12998 
    return not (self == other)
12999 
 
3064 chandransh 13000 
class getNoOfCustomersWithSuccessfulTransaction_args:
13001 
 
13002 
  thrift_spec = (
13003 
  )
13004 
 
13005 
  def read(self, iprot):
13006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13008 
      return
13009 
    iprot.readStructBegin()
13010 
    while True:
13011 
      (fname, ftype, fid) = iprot.readFieldBegin()
13012 
      if ftype == TType.STOP:
13013 
        break
13014 
      else:
13015 
        iprot.skip(ftype)
13016 
      iprot.readFieldEnd()
13017 
    iprot.readStructEnd()
13018 
 
13019 
  def write(self, oprot):
13020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13022 
      return
13023 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13024 
    oprot.writeFieldStop()
13025 
    oprot.writeStructEnd()
13026 
 
3431 rajveer 13027 
  def validate(self):
13028 
    return
13029 
 
13030 
 
3064 chandransh 13031 
  def __repr__(self):
13032 
    L = ['%s=%r' % (key, value)
13033 
      for key, value in self.__dict__.iteritems()]
13034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13035 
 
13036 
  def __eq__(self, other):
13037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13038 
 
13039 
  def __ne__(self, other):
13040 
    return not (self == other)
13041 
 
13042 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13043 
  """
13044 
  Attributes:
3064 chandransh 13045 
   - success
94 ashish 13046 
  """
13047 
 
13048 
  thrift_spec = (
3064 chandransh 13049 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13050 
  )
13051 
 
3064 chandransh 13052 
  def __init__(self, success=None,):
13053 
    self.success = success
94 ashish 13054 
 
13055 
  def read(self, iprot):
13056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13058 
      return
13059 
    iprot.readStructBegin()
13060 
    while True:
13061 
      (fname, ftype, fid) = iprot.readFieldBegin()
13062 
      if ftype == TType.STOP:
13063 
        break
3064 chandransh 13064 
      if fid == 0:
94 ashish 13065 
        if ftype == TType.I64:
3064 chandransh 13066 
          self.success = iprot.readI64();
94 ashish 13067 
        else:
13068 
          iprot.skip(ftype)
13069 
      else:
13070 
        iprot.skip(ftype)
13071 
      iprot.readFieldEnd()
13072 
    iprot.readStructEnd()
13073 
 
13074 
  def write(self, oprot):
13075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13077 
      return
3064 chandransh 13078 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13079 
    if self.success is not None:
3064 chandransh 13080 
      oprot.writeFieldBegin('success', TType.I64, 0)
13081 
      oprot.writeI64(self.success)
94 ashish 13082 
      oprot.writeFieldEnd()
13083 
    oprot.writeFieldStop()
13084 
    oprot.writeStructEnd()
13085 
 
3431 rajveer 13086 
  def validate(self):
13087 
    return
13088 
 
13089 
 
94 ashish 13090 
  def __repr__(self):
13091 
    L = ['%s=%r' % (key, value)
13092 
      for key, value in self.__dict__.iteritems()]
13093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13094 
 
13095 
  def __eq__(self, other):
13096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13097 
 
13098 
  def __ne__(self, other):
13099 
    return not (self == other)
13100 
 
3064 chandransh 13101 
class getValidOrdersAmountRange_args:
13102 
 
13103 
  thrift_spec = (
13104 
  )
13105 
 
13106 
  def read(self, iprot):
13107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13109 
      return
13110 
    iprot.readStructBegin()
13111 
    while True:
13112 
      (fname, ftype, fid) = iprot.readFieldBegin()
13113 
      if ftype == TType.STOP:
13114 
        break
13115 
      else:
13116 
        iprot.skip(ftype)
13117 
      iprot.readFieldEnd()
13118 
    iprot.readStructEnd()
13119 
 
13120 
  def write(self, oprot):
13121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13123 
      return
13124 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13125 
    oprot.writeFieldStop()
13126 
    oprot.writeStructEnd()
13127 
 
3431 rajveer 13128 
  def validate(self):
13129 
    return
13130 
 
13131 
 
3064 chandransh 13132 
  def __repr__(self):
13133 
    L = ['%s=%r' % (key, value)
13134 
      for key, value in self.__dict__.iteritems()]
13135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13136 
 
13137 
  def __eq__(self, other):
13138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13139 
 
13140 
  def __ne__(self, other):
13141 
    return not (self == other)
13142 
 
13143 
class getValidOrdersAmountRange_result:
94 ashish 13144 
  """
13145 
  Attributes:
13146 
   - success
13147 
  """
13148 
 
13149 
  thrift_spec = (
3064 chandransh 13150 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13151 
  )
13152 
 
3064 chandransh 13153 
  def __init__(self, success=None,):
94 ashish 13154 
    self.success = success
13155 
 
13156 
  def read(self, iprot):
13157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13159 
      return
13160 
    iprot.readStructBegin()
13161 
    while True:
13162 
      (fname, ftype, fid) = iprot.readFieldBegin()
13163 
      if ftype == TType.STOP:
13164 
        break
13165 
      if fid == 0:
483 rajveer 13166 
        if ftype == TType.LIST:
13167 
          self.success = []
6188 rajveer 13168 
          (_etype249, _size246) = iprot.readListBegin()
13169 
          for _i250 in xrange(_size246):
13170 
            _elem251 = iprot.readDouble();
13171 
            self.success.append(_elem251)
483 rajveer 13172 
          iprot.readListEnd()
94 ashish 13173 
        else:
13174 
          iprot.skip(ftype)
13175 
      else:
13176 
        iprot.skip(ftype)
13177 
      iprot.readFieldEnd()
13178 
    iprot.readStructEnd()
13179 
 
13180 
  def write(self, oprot):
13181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13183 
      return
3064 chandransh 13184 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13185 
    if self.success is not None:
483 rajveer 13186 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13187 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13188 
      for iter252 in self.success:
13189 
        oprot.writeDouble(iter252)
483 rajveer 13190 
      oprot.writeListEnd()
94 ashish 13191 
      oprot.writeFieldEnd()
13192 
    oprot.writeFieldStop()
13193 
    oprot.writeStructEnd()
13194 
 
3431 rajveer 13195 
  def validate(self):
13196 
    return
13197 
 
13198 
 
94 ashish 13199 
  def __repr__(self):
13200 
    L = ['%s=%r' % (key, value)
13201 
      for key, value in self.__dict__.iteritems()]
13202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13203 
 
13204 
  def __eq__(self, other):
13205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13206 
 
13207 
  def __ne__(self, other):
13208 
    return not (self == other)
13209 
 
3064 chandransh 13210 
class getValidOrders_args:
1528 ankur.sing 13211 
  """
13212 
  Attributes:
3064 chandransh 13213 
   - limit
5874 rajveer 13214 
   - onlyStore
1528 ankur.sing 13215 
  """
13216 
 
13217 
  thrift_spec = (
13218 
    None, # 0
3064 chandransh 13219 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13220 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13221 
  )
13222 
 
5874 rajveer 13223 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13224 
    self.limit = limit
5874 rajveer 13225 
    self.onlyStore = onlyStore
1528 ankur.sing 13226 
 
13227 
  def read(self, iprot):
13228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13230 
      return
13231 
    iprot.readStructBegin()
13232 
    while True:
13233 
      (fname, ftype, fid) = iprot.readFieldBegin()
13234 
      if ftype == TType.STOP:
13235 
        break
13236 
      if fid == 1:
13237 
        if ftype == TType.I64:
3064 chandransh 13238 
          self.limit = iprot.readI64();
1528 ankur.sing 13239 
        else:
13240 
          iprot.skip(ftype)
5874 rajveer 13241 
      elif fid == 2:
13242 
        if ftype == TType.BOOL:
13243 
          self.onlyStore = iprot.readBool();
13244 
        else:
13245 
          iprot.skip(ftype)
1528 ankur.sing 13246 
      else:
13247 
        iprot.skip(ftype)
13248 
      iprot.readFieldEnd()
13249 
    iprot.readStructEnd()
13250 
 
13251 
  def write(self, oprot):
13252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13254 
      return
3064 chandransh 13255 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13256 
    if self.limit is not None:
3064 chandransh 13257 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13258 
      oprot.writeI64(self.limit)
1528 ankur.sing 13259 
      oprot.writeFieldEnd()
5874 rajveer 13260 
    if self.onlyStore is not None:
13261 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13262 
      oprot.writeBool(self.onlyStore)
13263 
      oprot.writeFieldEnd()
1528 ankur.sing 13264 
    oprot.writeFieldStop()
13265 
    oprot.writeStructEnd()
13266 
 
3431 rajveer 13267 
  def validate(self):
13268 
    return
13269 
 
13270 
 
1528 ankur.sing 13271 
  def __repr__(self):
13272 
    L = ['%s=%r' % (key, value)
13273 
      for key, value in self.__dict__.iteritems()]
13274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13275 
 
13276 
  def __eq__(self, other):
13277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13278 
 
13279 
  def __ne__(self, other):
13280 
    return not (self == other)
13281 
 
3064 chandransh 13282 
class getValidOrders_result:
1528 ankur.sing 13283 
  """
13284 
  Attributes:
13285 
   - success
13286 
  """
13287 
 
13288 
  thrift_spec = (
3064 chandransh 13289 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13290 
  )
13291 
 
3064 chandransh 13292 
  def __init__(self, success=None,):
1528 ankur.sing 13293 
    self.success = success
13294 
 
13295 
  def read(self, iprot):
13296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13298 
      return
13299 
    iprot.readStructBegin()
13300 
    while True:
13301 
      (fname, ftype, fid) = iprot.readFieldBegin()
13302 
      if ftype == TType.STOP:
13303 
        break
13304 
      if fid == 0:
3064 chandransh 13305 
        if ftype == TType.LIST:
13306 
          self.success = []
6188 rajveer 13307 
          (_etype256, _size253) = iprot.readListBegin()
13308 
          for _i257 in xrange(_size253):
13309 
            _elem258 = Order()
13310 
            _elem258.read(iprot)
13311 
            self.success.append(_elem258)
3064 chandransh 13312 
          iprot.readListEnd()
1528 ankur.sing 13313 
        else:
13314 
          iprot.skip(ftype)
13315 
      else:
13316 
        iprot.skip(ftype)
13317 
      iprot.readFieldEnd()
13318 
    iprot.readStructEnd()
13319 
 
13320 
  def write(self, oprot):
13321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13323 
      return
3064 chandransh 13324 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13325 
    if self.success is not None:
3064 chandransh 13326 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13327 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13328 
      for iter259 in self.success:
13329 
        iter259.write(oprot)
3064 chandransh 13330 
      oprot.writeListEnd()
1528 ankur.sing 13331 
      oprot.writeFieldEnd()
13332 
    oprot.writeFieldStop()
13333 
    oprot.writeStructEnd()
13334 
 
3431 rajveer 13335 
  def validate(self):
13336 
    return
13337 
 
13338 
 
1528 ankur.sing 13339 
  def __repr__(self):
13340 
    L = ['%s=%r' % (key, value)
13341 
      for key, value in self.__dict__.iteritems()]
13342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13343 
 
13344 
  def __eq__(self, other):
13345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13346 
 
13347 
  def __ne__(self, other):
13348 
    return not (self == other)
13349 
 
1220 chandransh 13350 
class batchOrders_args:
13351 
  """
13352 
  Attributes:
13353 
   - warehouseId
13354 
  """
13355 
 
13356 
  thrift_spec = (
13357 
    None, # 0
13358 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13359 
  )
13360 
 
13361 
  def __init__(self, warehouseId=None,):
13362 
    self.warehouseId = warehouseId
13363 
 
13364 
  def read(self, iprot):
13365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13367 
      return
13368 
    iprot.readStructBegin()
13369 
    while True:
13370 
      (fname, ftype, fid) = iprot.readFieldBegin()
13371 
      if ftype == TType.STOP:
13372 
        break
13373 
      if fid == 1:
13374 
        if ftype == TType.I64:
13375 
          self.warehouseId = iprot.readI64();
13376 
        else:
13377 
          iprot.skip(ftype)
13378 
      else:
13379 
        iprot.skip(ftype)
13380 
      iprot.readFieldEnd()
13381 
    iprot.readStructEnd()
13382 
 
13383 
  def write(self, oprot):
13384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13386 
      return
13387 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13388 
    if self.warehouseId is not None:
1220 chandransh 13389 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13390 
      oprot.writeI64(self.warehouseId)
13391 
      oprot.writeFieldEnd()
13392 
    oprot.writeFieldStop()
13393 
    oprot.writeStructEnd()
13394 
 
3431 rajveer 13395 
  def validate(self):
13396 
    return
13397 
 
13398 
 
1220 chandransh 13399 
  def __repr__(self):
13400 
    L = ['%s=%r' % (key, value)
13401 
      for key, value in self.__dict__.iteritems()]
13402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13403 
 
13404 
  def __eq__(self, other):
13405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13406 
 
13407 
  def __ne__(self, other):
13408 
    return not (self == other)
13409 
 
13410 
class batchOrders_result:
13411 
  """
13412 
  Attributes:
13413 
   - success
13414 
   - ex
13415 
  """
13416 
 
13417 
  thrift_spec = (
13418 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13420 
  )
13421 
 
13422 
  def __init__(self, success=None, ex=None,):
13423 
    self.success = success
13424 
    self.ex = ex
13425 
 
13426 
  def read(self, iprot):
13427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13429 
      return
13430 
    iprot.readStructBegin()
13431 
    while True:
13432 
      (fname, ftype, fid) = iprot.readFieldBegin()
13433 
      if ftype == TType.STOP:
13434 
        break
13435 
      if fid == 0:
13436 
        if ftype == TType.LIST:
13437 
          self.success = []
6188 rajveer 13438 
          (_etype263, _size260) = iprot.readListBegin()
13439 
          for _i264 in xrange(_size260):
13440 
            _elem265 = Order()
13441 
            _elem265.read(iprot)
13442 
            self.success.append(_elem265)
1220 chandransh 13443 
          iprot.readListEnd()
13444 
        else:
13445 
          iprot.skip(ftype)
13446 
      elif fid == 1:
13447 
        if ftype == TType.STRUCT:
13448 
          self.ex = TransactionServiceException()
13449 
          self.ex.read(iprot)
13450 
        else:
13451 
          iprot.skip(ftype)
13452 
      else:
13453 
        iprot.skip(ftype)
13454 
      iprot.readFieldEnd()
13455 
    iprot.readStructEnd()
13456 
 
13457 
  def write(self, oprot):
13458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13460 
      return
13461 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13462 
    if self.success is not None:
1220 chandransh 13463 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13464 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13465 
      for iter266 in self.success:
13466 
        iter266.write(oprot)
1220 chandransh 13467 
      oprot.writeListEnd()
13468 
      oprot.writeFieldEnd()
3431 rajveer 13469 
    if self.ex is not None:
1220 chandransh 13470 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13471 
      self.ex.write(oprot)
13472 
      oprot.writeFieldEnd()
13473 
    oprot.writeFieldStop()
13474 
    oprot.writeStructEnd()
13475 
 
3431 rajveer 13476 
  def validate(self):
13477 
    return
13478 
 
13479 
 
1220 chandransh 13480 
  def __repr__(self):
13481 
    L = ['%s=%r' % (key, value)
13482 
      for key, value in self.__dict__.iteritems()]
13483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13484 
 
13485 
  def __eq__(self, other):
13486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13487 
 
13488 
  def __ne__(self, other):
13489 
    return not (self == other)
13490 
 
1208 chandransh 13491 
class markOrderAsOutOfStock_args:
13492 
  """
13493 
  Attributes:
13494 
   - orderId
13495 
  """
13496 
 
13497 
  thrift_spec = (
13498 
    None, # 0
13499 
    (1, TType.I64, 'orderId', None, None, ), # 1
13500 
  )
13501 
 
13502 
  def __init__(self, orderId=None,):
13503 
    self.orderId = orderId
13504 
 
13505 
  def read(self, iprot):
13506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13508 
      return
13509 
    iprot.readStructBegin()
13510 
    while True:
13511 
      (fname, ftype, fid) = iprot.readFieldBegin()
13512 
      if ftype == TType.STOP:
13513 
        break
13514 
      if fid == 1:
13515 
        if ftype == TType.I64:
13516 
          self.orderId = iprot.readI64();
13517 
        else:
13518 
          iprot.skip(ftype)
13519 
      else:
13520 
        iprot.skip(ftype)
13521 
      iprot.readFieldEnd()
13522 
    iprot.readStructEnd()
13523 
 
13524 
  def write(self, oprot):
13525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13527 
      return
13528 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13529 
    if self.orderId is not None:
1208 chandransh 13530 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13531 
      oprot.writeI64(self.orderId)
13532 
      oprot.writeFieldEnd()
13533 
    oprot.writeFieldStop()
13534 
    oprot.writeStructEnd()
13535 
 
3431 rajveer 13536 
  def validate(self):
13537 
    return
13538 
 
13539 
 
1208 chandransh 13540 
  def __repr__(self):
13541 
    L = ['%s=%r' % (key, value)
13542 
      for key, value in self.__dict__.iteritems()]
13543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13544 
 
13545 
  def __eq__(self, other):
13546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13547 
 
13548 
  def __ne__(self, other):
13549 
    return not (self == other)
13550 
 
13551 
class markOrderAsOutOfStock_result:
13552 
  """
13553 
  Attributes:
13554 
   - success
13555 
   - ex
13556 
  """
13557 
 
13558 
  thrift_spec = (
13559 
    (0, TType.BOOL, 'success', None, None, ), # 0
13560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13561 
  )
13562 
 
13563 
  def __init__(self, success=None, ex=None,):
13564 
    self.success = success
13565 
    self.ex = ex
13566 
 
13567 
  def read(self, iprot):
13568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13570 
      return
13571 
    iprot.readStructBegin()
13572 
    while True:
13573 
      (fname, ftype, fid) = iprot.readFieldBegin()
13574 
      if ftype == TType.STOP:
13575 
        break
13576 
      if fid == 0:
13577 
        if ftype == TType.BOOL:
13578 
          self.success = iprot.readBool();
13579 
        else:
13580 
          iprot.skip(ftype)
13581 
      elif fid == 1:
13582 
        if ftype == TType.STRUCT:
13583 
          self.ex = TransactionServiceException()
13584 
          self.ex.read(iprot)
13585 
        else:
13586 
          iprot.skip(ftype)
13587 
      else:
13588 
        iprot.skip(ftype)
13589 
      iprot.readFieldEnd()
13590 
    iprot.readStructEnd()
13591 
 
13592 
  def write(self, oprot):
13593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13595 
      return
13596 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13597 
    if self.success is not None:
1208 chandransh 13598 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13599 
      oprot.writeBool(self.success)
13600 
      oprot.writeFieldEnd()
3431 rajveer 13601 
    if self.ex is not None:
1208 chandransh 13602 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13603 
      self.ex.write(oprot)
13604 
      oprot.writeFieldEnd()
13605 
    oprot.writeFieldStop()
13606 
    oprot.writeStructEnd()
13607 
 
3431 rajveer 13608 
  def validate(self):
13609 
    return
13610 
 
13611 
 
1208 chandransh 13612 
  def __repr__(self):
13613 
    L = ['%s=%r' % (key, value)
13614 
      for key, value in self.__dict__.iteritems()]
13615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13616 
 
13617 
  def __eq__(self, other):
13618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13619 
 
13620 
  def __ne__(self, other):
13621 
    return not (self == other)
13622 
 
3064 chandransh 13623 
class verifyOrder_args:
759 chandransh 13624 
  """
13625 
  Attributes:
3064 chandransh 13626 
   - orderId
759 chandransh 13627 
  """
13628 
 
13629 
  thrift_spec = (
13630 
    None, # 0
3064 chandransh 13631 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13632 
  )
13633 
 
3064 chandransh 13634 
  def __init__(self, orderId=None,):
13635 
    self.orderId = orderId
759 chandransh 13636 
 
13637 
  def read(self, iprot):
13638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13640 
      return
13641 
    iprot.readStructBegin()
13642 
    while True:
13643 
      (fname, ftype, fid) = iprot.readFieldBegin()
13644 
      if ftype == TType.STOP:
13645 
        break
13646 
      if fid == 1:
13647 
        if ftype == TType.I64:
3064 chandransh 13648 
          self.orderId = iprot.readI64();
759 chandransh 13649 
        else:
13650 
          iprot.skip(ftype)
13651 
      else:
13652 
        iprot.skip(ftype)
13653 
      iprot.readFieldEnd()
13654 
    iprot.readStructEnd()
13655 
 
13656 
  def write(self, oprot):
13657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13659 
      return
3064 chandransh 13660 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13661 
    if self.orderId is not None:
3064 chandransh 13662 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13663 
      oprot.writeI64(self.orderId)
759 chandransh 13664 
      oprot.writeFieldEnd()
13665 
    oprot.writeFieldStop()
13666 
    oprot.writeStructEnd()
13667 
 
3431 rajveer 13668 
  def validate(self):
13669 
    return
13670 
 
13671 
 
759 chandransh 13672 
  def __repr__(self):
13673 
    L = ['%s=%r' % (key, value)
13674 
      for key, value in self.__dict__.iteritems()]
13675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13676 
 
13677 
  def __eq__(self, other):
13678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13679 
 
13680 
  def __ne__(self, other):
13681 
    return not (self == other)
13682 
 
3064 chandransh 13683 
class verifyOrder_result:
759 chandransh 13684 
  """
13685 
  Attributes:
13686 
   - success
13687 
   - ex
13688 
  """
13689 
 
13690 
  thrift_spec = (
13691 
    (0, TType.BOOL, 'success', None, None, ), # 0
13692 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13693 
  )
13694 
 
13695 
  def __init__(self, success=None, ex=None,):
13696 
    self.success = success
13697 
    self.ex = ex
13698 
 
13699 
  def read(self, iprot):
13700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13702 
      return
13703 
    iprot.readStructBegin()
13704 
    while True:
13705 
      (fname, ftype, fid) = iprot.readFieldBegin()
13706 
      if ftype == TType.STOP:
13707 
        break
13708 
      if fid == 0:
13709 
        if ftype == TType.BOOL:
13710 
          self.success = iprot.readBool();
13711 
        else:
13712 
          iprot.skip(ftype)
13713 
      elif fid == 1:
13714 
        if ftype == TType.STRUCT:
13715 
          self.ex = TransactionServiceException()
13716 
          self.ex.read(iprot)
13717 
        else:
13718 
          iprot.skip(ftype)
13719 
      else:
13720 
        iprot.skip(ftype)
13721 
      iprot.readFieldEnd()
13722 
    iprot.readStructEnd()
13723 
 
13724 
  def write(self, oprot):
13725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13727 
      return
3064 chandransh 13728 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13729 
    if self.success is not None:
759 chandransh 13730 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13731 
      oprot.writeBool(self.success)
13732 
      oprot.writeFieldEnd()
3431 rajveer 13733 
    if self.ex is not None:
759 chandransh 13734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13735 
      self.ex.write(oprot)
13736 
      oprot.writeFieldEnd()
13737 
    oprot.writeFieldStop()
13738 
    oprot.writeStructEnd()
13739 
 
3431 rajveer 13740 
  def validate(self):
13741 
    return
13742 
 
13743 
 
759 chandransh 13744 
  def __repr__(self):
13745 
    L = ['%s=%r' % (key, value)
13746 
      for key, value in self.__dict__.iteritems()]
13747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13748 
 
13749 
  def __eq__(self, other):
13750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13751 
 
13752 
  def __ne__(self, other):
13753 
    return not (self == other)
13754 
 
3064 chandransh 13755 
class acceptOrder_args:
1113 chandransh 13756 
  """
13757 
  Attributes:
3064 chandransh 13758 
   - orderId
1113 chandransh 13759 
  """
13760 
 
13761 
  thrift_spec = (
13762 
    None, # 0
3064 chandransh 13763 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13764 
  )
13765 
 
3064 chandransh 13766 
  def __init__(self, orderId=None,):
13767 
    self.orderId = orderId
1113 chandransh 13768 
 
13769 
  def read(self, iprot):
13770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13772 
      return
13773 
    iprot.readStructBegin()
13774 
    while True:
13775 
      (fname, ftype, fid) = iprot.readFieldBegin()
13776 
      if ftype == TType.STOP:
13777 
        break
13778 
      if fid == 1:
13779 
        if ftype == TType.I64:
3064 chandransh 13780 
          self.orderId = iprot.readI64();
1113 chandransh 13781 
        else:
13782 
          iprot.skip(ftype)
13783 
      else:
13784 
        iprot.skip(ftype)
13785 
      iprot.readFieldEnd()
13786 
    iprot.readStructEnd()
13787 
 
13788 
  def write(self, oprot):
13789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13791 
      return
3064 chandransh 13792 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13793 
    if self.orderId is not None:
3064 chandransh 13794 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13795 
      oprot.writeI64(self.orderId)
1113 chandransh 13796 
      oprot.writeFieldEnd()
13797 
    oprot.writeFieldStop()
13798 
    oprot.writeStructEnd()
13799 
 
3431 rajveer 13800 
  def validate(self):
13801 
    return
13802 
 
13803 
 
1113 chandransh 13804 
  def __repr__(self):
13805 
    L = ['%s=%r' % (key, value)
13806 
      for key, value in self.__dict__.iteritems()]
13807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13808 
 
13809 
  def __eq__(self, other):
13810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13811 
 
13812 
  def __ne__(self, other):
13813 
    return not (self == other)
13814 
 
3064 chandransh 13815 
class acceptOrder_result:
1113 chandransh 13816 
  """
13817 
  Attributes:
13818 
   - success
13819 
   - ex
13820 
  """
13821 
 
13822 
  thrift_spec = (
3064 chandransh 13823 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13824 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13825 
  )
13826 
 
13827 
  def __init__(self, success=None, ex=None,):
13828 
    self.success = success
13829 
    self.ex = ex
13830 
 
13831 
  def read(self, iprot):
13832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13834 
      return
13835 
    iprot.readStructBegin()
13836 
    while True:
13837 
      (fname, ftype, fid) = iprot.readFieldBegin()
13838 
      if ftype == TType.STOP:
13839 
        break
13840 
      if fid == 0:
3064 chandransh 13841 
        if ftype == TType.BOOL:
13842 
          self.success = iprot.readBool();
1113 chandransh 13843 
        else:
13844 
          iprot.skip(ftype)
13845 
      elif fid == 1:
13846 
        if ftype == TType.STRUCT:
13847 
          self.ex = TransactionServiceException()
13848 
          self.ex.read(iprot)
13849 
        else:
13850 
          iprot.skip(ftype)
13851 
      else:
13852 
        iprot.skip(ftype)
13853 
      iprot.readFieldEnd()
13854 
    iprot.readStructEnd()
13855 
 
13856 
  def write(self, oprot):
13857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13859 
      return
3064 chandransh 13860 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13861 
    if self.success is not None:
3064 chandransh 13862 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13863 
      oprot.writeBool(self.success)
1113 chandransh 13864 
      oprot.writeFieldEnd()
3431 rajveer 13865 
    if self.ex is not None:
1113 chandransh 13866 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13867 
      self.ex.write(oprot)
13868 
      oprot.writeFieldEnd()
13869 
    oprot.writeFieldStop()
13870 
    oprot.writeStructEnd()
13871 
 
3431 rajveer 13872 
  def validate(self):
13873 
    return
13874 
 
13875 
 
1113 chandransh 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 
 
3064 chandransh 13887 
class addBillingDetails_args:
1135 chandransh 13888 
  """
13889 
  Attributes:
3064 chandransh 13890 
   - orderId
13891 
   - invoice_number
4658 mandeep.dh 13892 
   - serialNumber
4283 anupam.sin 13893 
   - itemNumber
3064 chandransh 13894 
   - billed_by
4264 rajveer 13895 
   - jacketNumber
4283 anupam.sin 13896 
   - billingType
5110 mandeep.dh 13897 
   - fulfilmentWarehouseId
4763 rajveer 13898 
   - authorize
1135 chandransh 13899 
  """
13900 
 
13901 
  thrift_spec = (
13902 
    None, # 0
3064 chandransh 13903 
    (1, TType.I64, 'orderId', None, None, ), # 1
13904 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13905 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13906 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13907 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13908 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13909 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13910 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13911 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13912 
  )
13913 
 
5110 mandeep.dh 13914 
  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 13915 
    self.orderId = orderId
13916 
    self.invoice_number = invoice_number
4658 mandeep.dh 13917 
    self.serialNumber = serialNumber
4283 anupam.sin 13918 
    self.itemNumber = itemNumber
3064 chandransh 13919 
    self.billed_by = billed_by
4264 rajveer 13920 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13921 
    self.billingType = billingType
5110 mandeep.dh 13922 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13923 
    self.authorize = authorize
1135 chandransh 13924 
 
13925 
  def read(self, iprot):
13926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13928 
      return
13929 
    iprot.readStructBegin()
13930 
    while True:
13931 
      (fname, ftype, fid) = iprot.readFieldBegin()
13932 
      if ftype == TType.STOP:
13933 
        break
13934 
      if fid == 1:
13935 
        if ftype == TType.I64:
3064 chandransh 13936 
          self.orderId = iprot.readI64();
1135 chandransh 13937 
        else:
13938 
          iprot.skip(ftype)
13939 
      elif fid == 2:
3064 chandransh 13940 
        if ftype == TType.STRING:
13941 
          self.invoice_number = iprot.readString();
1135 chandransh 13942 
        else:
13943 
          iprot.skip(ftype)
3064 chandransh 13944 
      elif fid == 3:
5411 rajveer 13945 
        if ftype == TType.LIST:
13946 
          self.serialNumber = []
6188 rajveer 13947 
          (_etype270, _size267) = iprot.readListBegin()
13948 
          for _i271 in xrange(_size267):
13949 
            _elem272 = iprot.readString();
13950 
            self.serialNumber.append(_elem272)
5411 rajveer 13951 
          iprot.readListEnd()
3064 chandransh 13952 
        else:
13953 
          iprot.skip(ftype)
13954 
      elif fid == 4:
5411 rajveer 13955 
        if ftype == TType.LIST:
13956 
          self.itemNumber = []
6188 rajveer 13957 
          (_etype276, _size273) = iprot.readListBegin()
13958 
          for _i277 in xrange(_size273):
13959 
            _elem278 = iprot.readString();
13960 
            self.itemNumber.append(_elem278)
5411 rajveer 13961 
          iprot.readListEnd()
3064 chandransh 13962 
        else:
13963 
          iprot.skip(ftype)
13964 
      elif fid == 5:
13965 
        if ftype == TType.STRING:
4283 anupam.sin 13966 
          self.billed_by = iprot.readString();
3064 chandransh 13967 
        else:
13968 
          iprot.skip(ftype)
13969 
      elif fid == 6:
13970 
        if ftype == TType.I64:
4283 anupam.sin 13971 
          self.jacketNumber = iprot.readI64();
13972 
        else:
13973 
          iprot.skip(ftype)
13974 
      elif fid == 7:
13975 
        if ftype == TType.I64:
3064 chandransh 13976 
          self.billingType = iprot.readI64();
13977 
        else:
13978 
          iprot.skip(ftype)
4283 anupam.sin 13979 
      elif fid == 8:
13980 
        if ftype == TType.I64:
5110 mandeep.dh 13981 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13982 
        else:
13983 
          iprot.skip(ftype)
4763 rajveer 13984 
      elif fid == 9:
13985 
        if ftype == TType.BOOL:
13986 
          self.authorize = iprot.readBool();
13987 
        else:
13988 
          iprot.skip(ftype)
1246 chandransh 13989 
      else:
13990 
        iprot.skip(ftype)
13991 
      iprot.readFieldEnd()
13992 
    iprot.readStructEnd()
13993 
 
13994 
  def write(self, oprot):
13995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13997 
      return
4283 anupam.sin 13998 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13999 
    if self.orderId is not None:
3064 chandransh 14000 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14001 
      oprot.writeI64(self.orderId)
1246 chandransh 14002 
      oprot.writeFieldEnd()
4283 anupam.sin 14003 
    if self.invoice_number is not None:
14004 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14005 
      oprot.writeString(self.invoice_number)
1246 chandransh 14006 
      oprot.writeFieldEnd()
4658 mandeep.dh 14007 
    if self.serialNumber is not None:
5411 rajveer 14008 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14009 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14010 
      for iter279 in self.serialNumber:
14011 
        oprot.writeString(iter279)
5411 rajveer 14012 
      oprot.writeListEnd()
3064 chandransh 14013 
      oprot.writeFieldEnd()
3431 rajveer 14014 
    if self.itemNumber is not None:
5411 rajveer 14015 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14016 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14017 
      for iter280 in self.itemNumber:
14018 
        oprot.writeString(iter280)
5411 rajveer 14019 
      oprot.writeListEnd()
3064 chandransh 14020 
      oprot.writeFieldEnd()
4283 anupam.sin 14021 
    if self.billed_by is not None:
14022 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
14023 
      oprot.writeString(self.billed_by)
3064 chandransh 14024 
      oprot.writeFieldEnd()
4283 anupam.sin 14025 
    if self.jacketNumber is not None:
14026 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
14027 
      oprot.writeI64(self.jacketNumber)
14028 
      oprot.writeFieldEnd()
3431 rajveer 14029 
    if self.billingType is not None:
4283 anupam.sin 14030 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 14031 
      oprot.writeI64(self.billingType)
14032 
      oprot.writeFieldEnd()
5110 mandeep.dh 14033 
    if self.fulfilmentWarehouseId is not None:
14034 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
14035 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14036 
      oprot.writeFieldEnd()
4763 rajveer 14037 
    if self.authorize is not None:
14038 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
14039 
      oprot.writeBool(self.authorize)
14040 
      oprot.writeFieldEnd()
1246 chandransh 14041 
    oprot.writeFieldStop()
14042 
    oprot.writeStructEnd()
14043 
 
3431 rajveer 14044 
  def validate(self):
14045 
    return
14046 
 
14047 
 
1246 chandransh 14048 
  def __repr__(self):
14049 
    L = ['%s=%r' % (key, value)
14050 
      for key, value in self.__dict__.iteritems()]
14051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14052 
 
14053 
  def __eq__(self, other):
14054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14055 
 
14056 
  def __ne__(self, other):
14057 
    return not (self == other)
14058 
 
4283 anupam.sin 14059 
class addBillingDetails_result:
1246 chandransh 14060 
  """
14061 
  Attributes:
3064 chandransh 14062 
   - success
1246 chandransh 14063 
   - ex
14064 
  """
14065 
 
14066 
  thrift_spec = (
3064 chandransh 14067 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14068 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14069 
  )
14070 
 
3064 chandransh 14071 
  def __init__(self, success=None, ex=None,):
14072 
    self.success = success
1246 chandransh 14073 
    self.ex = ex
14074 
 
14075 
  def read(self, iprot):
14076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14078 
      return
14079 
    iprot.readStructBegin()
14080 
    while True:
14081 
      (fname, ftype, fid) = iprot.readFieldBegin()
14082 
      if ftype == TType.STOP:
14083 
        break
3064 chandransh 14084 
      if fid == 0:
14085 
        if ftype == TType.BOOL:
14086 
          self.success = iprot.readBool();
14087 
        else:
14088 
          iprot.skip(ftype)
14089 
      elif fid == 1:
1246 chandransh 14090 
        if ftype == TType.STRUCT:
14091 
          self.ex = TransactionServiceException()
14092 
          self.ex.read(iprot)
14093 
        else:
14094 
          iprot.skip(ftype)
14095 
      else:
14096 
        iprot.skip(ftype)
14097 
      iprot.readFieldEnd()
14098 
    iprot.readStructEnd()
14099 
 
14100 
  def write(self, oprot):
14101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14103 
      return
4283 anupam.sin 14104 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14105 
    if self.success is not None:
3064 chandransh 14106 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14107 
      oprot.writeBool(self.success)
14108 
      oprot.writeFieldEnd()
3431 rajveer 14109 
    if self.ex is not None:
1246 chandransh 14110 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14111 
      self.ex.write(oprot)
14112 
      oprot.writeFieldEnd()
14113 
    oprot.writeFieldStop()
14114 
    oprot.writeStructEnd()
14115 
 
3431 rajveer 14116 
  def validate(self):
14117 
    return
14118 
 
14119 
 
1246 chandransh 14120 
  def __repr__(self):
14121 
    L = ['%s=%r' % (key, value)
14122 
      for key, value in self.__dict__.iteritems()]
14123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14124 
 
14125 
  def __eq__(self, other):
14126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14127 
 
14128 
  def __ne__(self, other):
14129 
    return not (self == other)
14130 
 
4579 rajveer 14131 
class addInvoiceNumber_args:
14132 
  """
14133 
  Attributes:
14134 
   - orderId
14135 
   - invoiceNumber
4763 rajveer 14136 
   - color
6756 amar.kumar 14137 
   - serialNumber
14138 
   - itemNumber
4579 rajveer 14139 
  """
14140 
 
14141 
  thrift_spec = (
14142 
    None, # 0
14143 
    (1, TType.I64, 'orderId', None, None, ), # 1
14144 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14145 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14146 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14147 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14148 
  )
14149 
 
6756 amar.kumar 14150 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14151 
    self.orderId = orderId
14152 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14153 
    self.color = color
6756 amar.kumar 14154 
    self.serialNumber = serialNumber
14155 
    self.itemNumber = itemNumber
4579 rajveer 14156 
 
14157 
  def read(self, iprot):
14158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14160 
      return
14161 
    iprot.readStructBegin()
14162 
    while True:
14163 
      (fname, ftype, fid) = iprot.readFieldBegin()
14164 
      if ftype == TType.STOP:
14165 
        break
14166 
      if fid == 1:
14167 
        if ftype == TType.I64:
14168 
          self.orderId = iprot.readI64();
14169 
        else:
14170 
          iprot.skip(ftype)
14171 
      elif fid == 2:
14172 
        if ftype == TType.STRING:
14173 
          self.invoiceNumber = iprot.readString();
14174 
        else:
14175 
          iprot.skip(ftype)
4763 rajveer 14176 
      elif fid == 3:
14177 
        if ftype == TType.STRING:
14178 
          self.color = iprot.readString();
14179 
        else:
14180 
          iprot.skip(ftype)
6756 amar.kumar 14181 
      elif fid == 4:
14182 
        if ftype == TType.STRING:
14183 
          self.serialNumber = iprot.readString();
14184 
        else:
14185 
          iprot.skip(ftype)
14186 
      elif fid == 5:
14187 
        if ftype == TType.STRING:
14188 
          self.itemNumber = iprot.readString();
14189 
        else:
14190 
          iprot.skip(ftype)
4579 rajveer 14191 
      else:
14192 
        iprot.skip(ftype)
14193 
      iprot.readFieldEnd()
14194 
    iprot.readStructEnd()
14195 
 
14196 
  def write(self, oprot):
14197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14199 
      return
14200 
    oprot.writeStructBegin('addInvoiceNumber_args')
14201 
    if self.orderId is not None:
14202 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14203 
      oprot.writeI64(self.orderId)
14204 
      oprot.writeFieldEnd()
14205 
    if self.invoiceNumber is not None:
14206 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14207 
      oprot.writeString(self.invoiceNumber)
14208 
      oprot.writeFieldEnd()
4763 rajveer 14209 
    if self.color is not None:
14210 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14211 
      oprot.writeString(self.color)
14212 
      oprot.writeFieldEnd()
6756 amar.kumar 14213 
    if self.serialNumber is not None:
14214 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14215 
      oprot.writeString(self.serialNumber)
14216 
      oprot.writeFieldEnd()
14217 
    if self.itemNumber is not None:
14218 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14219 
      oprot.writeString(self.itemNumber)
14220 
      oprot.writeFieldEnd()
4579 rajveer 14221 
    oprot.writeFieldStop()
14222 
    oprot.writeStructEnd()
14223 
 
14224 
  def validate(self):
14225 
    return
14226 
 
14227 
 
14228 
  def __repr__(self):
14229 
    L = ['%s=%r' % (key, value)
14230 
      for key, value in self.__dict__.iteritems()]
14231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14232 
 
14233 
  def __eq__(self, other):
14234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14235 
 
14236 
  def __ne__(self, other):
14237 
    return not (self == other)
14238 
 
14239 
class addInvoiceNumber_result:
14240 
  """
14241 
  Attributes:
14242 
   - ex
14243 
  """
14244 
 
14245 
  thrift_spec = (
14246 
    None, # 0
14247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14248 
  )
14249 
 
14250 
  def __init__(self, ex=None,):
14251 
    self.ex = ex
14252 
 
14253 
  def read(self, iprot):
14254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14256 
      return
14257 
    iprot.readStructBegin()
14258 
    while True:
14259 
      (fname, ftype, fid) = iprot.readFieldBegin()
14260 
      if ftype == TType.STOP:
14261 
        break
14262 
      if fid == 1:
14263 
        if ftype == TType.STRUCT:
14264 
          self.ex = TransactionServiceException()
14265 
          self.ex.read(iprot)
14266 
        else:
14267 
          iprot.skip(ftype)
14268 
      else:
14269 
        iprot.skip(ftype)
14270 
      iprot.readFieldEnd()
14271 
    iprot.readStructEnd()
14272 
 
14273 
  def write(self, oprot):
14274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14276 
      return
14277 
    oprot.writeStructBegin('addInvoiceNumber_result')
14278 
    if self.ex is not None:
14279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14280 
      self.ex.write(oprot)
14281 
      oprot.writeFieldEnd()
14282 
    oprot.writeFieldStop()
14283 
    oprot.writeStructEnd()
14284 
 
14285 
  def validate(self):
14286 
    return
14287 
 
14288 
 
14289 
  def __repr__(self):
14290 
    L = ['%s=%r' % (key, value)
14291 
      for key, value in self.__dict__.iteritems()]
14292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14293 
 
14294 
  def __eq__(self, other):
14295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14296 
 
14297 
  def __ne__(self, other):
14298 
    return not (self == other)
14299 
 
4910 phani.kuma 14300 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14301 
  """
14302 
  Attributes:
3064 chandransh 14303 
   - warehouseId
1408 ankur.sing 14304 
   - providerId
3064 chandransh 14305 
   - cod
4910 phani.kuma 14306 
   - orderIds
1408 ankur.sing 14307 
  """
14308 
 
14309 
  thrift_spec = (
14310 
    None, # 0
3064 chandransh 14311 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14312 
    (2, TType.I64, 'providerId', None, None, ), # 2
14313 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14314 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14315 
  )
14316 
 
4910 phani.kuma 14317 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14318 
    self.warehouseId = warehouseId
1408 ankur.sing 14319 
    self.providerId = providerId
3064 chandransh 14320 
    self.cod = cod
4910 phani.kuma 14321 
    self.orderIds = orderIds
1408 ankur.sing 14322 
 
14323 
  def read(self, iprot):
14324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14326 
      return
14327 
    iprot.readStructBegin()
14328 
    while True:
14329 
      (fname, ftype, fid) = iprot.readFieldBegin()
14330 
      if ftype == TType.STOP:
14331 
        break
14332 
      if fid == 1:
14333 
        if ftype == TType.I64:
3064 chandransh 14334 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14335 
        else:
14336 
          iprot.skip(ftype)
14337 
      elif fid == 2:
14338 
        if ftype == TType.I64:
3064 chandransh 14339 
          self.providerId = iprot.readI64();
1408 ankur.sing 14340 
        else:
14341 
          iprot.skip(ftype)
3064 chandransh 14342 
      elif fid == 3:
14343 
        if ftype == TType.BOOL:
14344 
          self.cod = iprot.readBool();
14345 
        else:
14346 
          iprot.skip(ftype)
4910 phani.kuma 14347 
      elif fid == 4:
14348 
        if ftype == TType.LIST:
14349 
          self.orderIds = []
6188 rajveer 14350 
          (_etype284, _size281) = iprot.readListBegin()
14351 
          for _i285 in xrange(_size281):
14352 
            _elem286 = iprot.readI64();
14353 
            self.orderIds.append(_elem286)
4910 phani.kuma 14354 
          iprot.readListEnd()
14355 
        else:
14356 
          iprot.skip(ftype)
1408 ankur.sing 14357 
      else:
14358 
        iprot.skip(ftype)
14359 
      iprot.readFieldEnd()
14360 
    iprot.readStructEnd()
14361 
 
14362 
  def write(self, oprot):
14363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14365 
      return
4910 phani.kuma 14366 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14367 
    if self.warehouseId is not None:
3064 chandransh 14368 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14369 
      oprot.writeI64(self.warehouseId)
14370 
      oprot.writeFieldEnd()
3431 rajveer 14371 
    if self.providerId is not None:
3064 chandransh 14372 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14373 
      oprot.writeI64(self.providerId)
14374 
      oprot.writeFieldEnd()
3431 rajveer 14375 
    if self.cod is not None:
3064 chandransh 14376 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14377 
      oprot.writeBool(self.cod)
1408 ankur.sing 14378 
      oprot.writeFieldEnd()
4910 phani.kuma 14379 
    if self.orderIds is not None:
14380 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14381 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14382 
      for iter287 in self.orderIds:
14383 
        oprot.writeI64(iter287)
4910 phani.kuma 14384 
      oprot.writeListEnd()
14385 
      oprot.writeFieldEnd()
1408 ankur.sing 14386 
    oprot.writeFieldStop()
14387 
    oprot.writeStructEnd()
14388 
 
3431 rajveer 14389 
  def validate(self):
14390 
    return
14391 
 
14392 
 
1408 ankur.sing 14393 
  def __repr__(self):
14394 
    L = ['%s=%r' % (key, value)
14395 
      for key, value in self.__dict__.iteritems()]
14396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14397 
 
14398 
  def __eq__(self, other):
14399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14400 
 
14401 
  def __ne__(self, other):
14402 
    return not (self == other)
14403 
 
4910 phani.kuma 14404 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14405 
  """
14406 
  Attributes:
14407 
   - success
3064 chandransh 14408 
   - ex
1408 ankur.sing 14409 
  """
14410 
 
14411 
  thrift_spec = (
3064 chandransh 14412 
    (0, TType.BOOL, 'success', None, None, ), # 0
14413 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14414 
  )
14415 
 
3064 chandransh 14416 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14417 
    self.success = success
3064 chandransh 14418 
    self.ex = ex
1408 ankur.sing 14419 
 
14420 
  def read(self, iprot):
14421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14423 
      return
14424 
    iprot.readStructBegin()
14425 
    while True:
14426 
      (fname, ftype, fid) = iprot.readFieldBegin()
14427 
      if ftype == TType.STOP:
14428 
        break
14429 
      if fid == 0:
3064 chandransh 14430 
        if ftype == TType.BOOL:
14431 
          self.success = iprot.readBool();
1408 ankur.sing 14432 
        else:
14433 
          iprot.skip(ftype)
3064 chandransh 14434 
      elif fid == 1:
14435 
        if ftype == TType.STRUCT:
14436 
          self.ex = TransactionServiceException()
14437 
          self.ex.read(iprot)
14438 
        else:
14439 
          iprot.skip(ftype)
1408 ankur.sing 14440 
      else:
14441 
        iprot.skip(ftype)
14442 
      iprot.readFieldEnd()
14443 
    iprot.readStructEnd()
14444 
 
14445 
  def write(self, oprot):
14446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14448 
      return
4910 phani.kuma 14449 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14450 
    if self.success is not None:
3064 chandransh 14451 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14452 
      oprot.writeBool(self.success)
1408 ankur.sing 14453 
      oprot.writeFieldEnd()
3431 rajveer 14454 
    if self.ex is not None:
3064 chandransh 14455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14456 
      self.ex.write(oprot)
14457 
      oprot.writeFieldEnd()
1408 ankur.sing 14458 
    oprot.writeFieldStop()
14459 
    oprot.writeStructEnd()
14460 
 
3431 rajveer 14461 
  def validate(self):
14462 
    return
14463 
 
14464 
 
1408 ankur.sing 14465 
  def __repr__(self):
14466 
    L = ['%s=%r' % (key, value)
14467 
      for key, value in self.__dict__.iteritems()]
14468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14469 
 
14470 
  def __eq__(self, other):
14471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14472 
 
14473 
  def __ne__(self, other):
14474 
    return not (self == other)
14475 
 
5676 rajveer 14476 
class markOrdersAsReturnedFromStore_args:
14477 
  """
14478 
  Attributes:
14479 
   - providerId
14480 
   - orderIds
5713 rajveer 14481 
   - awbs
5676 rajveer 14482 
  """
14483 
 
14484 
  thrift_spec = (
14485 
    None, # 0
14486 
    (1, TType.I64, 'providerId', None, None, ), # 1
14487 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14488 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14489 
  )
14490 
 
5713 rajveer 14491 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14492 
    self.providerId = providerId
14493 
    self.orderIds = orderIds
5713 rajveer 14494 
    self.awbs = awbs
5676 rajveer 14495 
 
14496 
  def read(self, iprot):
14497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14499 
      return
14500 
    iprot.readStructBegin()
14501 
    while True:
14502 
      (fname, ftype, fid) = iprot.readFieldBegin()
14503 
      if ftype == TType.STOP:
14504 
        break
14505 
      if fid == 1:
14506 
        if ftype == TType.I64:
14507 
          self.providerId = iprot.readI64();
14508 
        else:
14509 
          iprot.skip(ftype)
14510 
      elif fid == 2:
14511 
        if ftype == TType.LIST:
14512 
          self.orderIds = []
6188 rajveer 14513 
          (_etype291, _size288) = iprot.readListBegin()
14514 
          for _i292 in xrange(_size288):
14515 
            _elem293 = iprot.readI64();
14516 
            self.orderIds.append(_elem293)
5676 rajveer 14517 
          iprot.readListEnd()
14518 
        else:
14519 
          iprot.skip(ftype)
5713 rajveer 14520 
      elif fid == 3:
14521 
        if ftype == TType.LIST:
14522 
          self.awbs = []
6188 rajveer 14523 
          (_etype297, _size294) = iprot.readListBegin()
14524 
          for _i298 in xrange(_size294):
14525 
            _elem299 = iprot.readString();
14526 
            self.awbs.append(_elem299)
5713 rajveer 14527 
          iprot.readListEnd()
14528 
        else:
14529 
          iprot.skip(ftype)
5676 rajveer 14530 
      else:
14531 
        iprot.skip(ftype)
14532 
      iprot.readFieldEnd()
14533 
    iprot.readStructEnd()
14534 
 
14535 
  def write(self, oprot):
14536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14538 
      return
14539 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14540 
    if self.providerId is not None:
14541 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14542 
      oprot.writeI64(self.providerId)
14543 
      oprot.writeFieldEnd()
14544 
    if self.orderIds is not None:
14545 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14546 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14547 
      for iter300 in self.orderIds:
14548 
        oprot.writeI64(iter300)
5676 rajveer 14549 
      oprot.writeListEnd()
14550 
      oprot.writeFieldEnd()
5713 rajveer 14551 
    if self.awbs is not None:
14552 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14553 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14554 
      for iter301 in self.awbs:
14555 
        oprot.writeString(iter301)
5713 rajveer 14556 
      oprot.writeListEnd()
14557 
      oprot.writeFieldEnd()
5676 rajveer 14558 
    oprot.writeFieldStop()
14559 
    oprot.writeStructEnd()
14560 
 
14561 
  def validate(self):
14562 
    return
14563 
 
14564 
 
14565 
  def __repr__(self):
14566 
    L = ['%s=%r' % (key, value)
14567 
      for key, value in self.__dict__.iteritems()]
14568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14569 
 
14570 
  def __eq__(self, other):
14571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14572 
 
14573 
  def __ne__(self, other):
14574 
    return not (self == other)
14575 
 
14576 
class markOrdersAsReturnedFromStore_result:
14577 
  """
14578 
  Attributes:
14579 
   - success
14580 
   - ex
14581 
  """
14582 
 
14583 
  thrift_spec = (
14584 
    (0, TType.BOOL, 'success', None, None, ), # 0
14585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14586 
  )
14587 
 
14588 
  def __init__(self, success=None, ex=None,):
14589 
    self.success = success
14590 
    self.ex = ex
14591 
 
14592 
  def read(self, iprot):
14593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14595 
      return
14596 
    iprot.readStructBegin()
14597 
    while True:
14598 
      (fname, ftype, fid) = iprot.readFieldBegin()
14599 
      if ftype == TType.STOP:
14600 
        break
14601 
      if fid == 0:
14602 
        if ftype == TType.BOOL:
14603 
          self.success = iprot.readBool();
14604 
        else:
14605 
          iprot.skip(ftype)
14606 
      elif fid == 1:
14607 
        if ftype == TType.STRUCT:
14608 
          self.ex = TransactionServiceException()
14609 
          self.ex.read(iprot)
14610 
        else:
14611 
          iprot.skip(ftype)
14612 
      else:
14613 
        iprot.skip(ftype)
14614 
      iprot.readFieldEnd()
14615 
    iprot.readStructEnd()
14616 
 
14617 
  def write(self, oprot):
14618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14620 
      return
14621 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14622 
    if self.success is not None:
14623 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14624 
      oprot.writeBool(self.success)
14625 
      oprot.writeFieldEnd()
14626 
    if self.ex is not None:
14627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14628 
      self.ex.write(oprot)
14629 
      oprot.writeFieldEnd()
14630 
    oprot.writeFieldStop()
14631 
    oprot.writeStructEnd()
14632 
 
14633 
  def validate(self):
14634 
    return
14635 
 
14636 
 
14637 
  def __repr__(self):
14638 
    L = ['%s=%r' % (key, value)
14639 
      for key, value in self.__dict__.iteritems()]
14640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14641 
 
14642 
  def __eq__(self, other):
14643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14644 
 
14645 
  def __ne__(self, other):
14646 
    return not (self == other)
14647 
 
4910 phani.kuma 14648 
class markOrdersAsPickedUp_args:
4410 rajveer 14649 
  """
14650 
  Attributes:
14651 
   - providerId
4910 phani.kuma 14652 
   - pickupDetails
4410 rajveer 14653 
  """
14654 
 
14655 
  thrift_spec = (
14656 
    None, # 0
4910 phani.kuma 14657 
    (1, TType.I64, 'providerId', None, None, ), # 1
14658 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14659 
  )
14660 
 
4910 phani.kuma 14661 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14662 
    self.providerId = providerId
4910 phani.kuma 14663 
    self.pickupDetails = pickupDetails
4410 rajveer 14664 
 
14665 
  def read(self, iprot):
14666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14668 
      return
14669 
    iprot.readStructBegin()
14670 
    while True:
14671 
      (fname, ftype, fid) = iprot.readFieldBegin()
14672 
      if ftype == TType.STOP:
14673 
        break
14674 
      if fid == 1:
14675 
        if ftype == TType.I64:
4910 phani.kuma 14676 
          self.providerId = iprot.readI64();
4410 rajveer 14677 
        else:
14678 
          iprot.skip(ftype)
14679 
      elif fid == 2:
4910 phani.kuma 14680 
        if ftype == TType.MAP:
14681 
          self.pickupDetails = {}
6188 rajveer 14682 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14683 
          for _i306 in xrange(_size302):
14684 
            _key307 = iprot.readString();
14685 
            _val308 = iprot.readString();
14686 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14687 
          iprot.readMapEnd()
4410 rajveer 14688 
        else:
14689 
          iprot.skip(ftype)
14690 
      else:
14691 
        iprot.skip(ftype)
14692 
      iprot.readFieldEnd()
14693 
    iprot.readStructEnd()
14694 
 
14695 
  def write(self, oprot):
14696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14698 
      return
4910 phani.kuma 14699 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14700 
    if self.providerId is not None:
4910 phani.kuma 14701 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14702 
      oprot.writeI64(self.providerId)
14703 
      oprot.writeFieldEnd()
4910 phani.kuma 14704 
    if self.pickupDetails is not None:
14705 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14706 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14707 
      for kiter309,viter310 in self.pickupDetails.items():
14708 
        oprot.writeString(kiter309)
14709 
        oprot.writeString(viter310)
4910 phani.kuma 14710 
      oprot.writeMapEnd()
4410 rajveer 14711 
      oprot.writeFieldEnd()
14712 
    oprot.writeFieldStop()
14713 
    oprot.writeStructEnd()
14714 
 
14715 
  def validate(self):
14716 
    return
14717 
 
14718 
 
14719 
  def __repr__(self):
14720 
    L = ['%s=%r' % (key, value)
14721 
      for key, value in self.__dict__.iteritems()]
14722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14723 
 
14724 
  def __eq__(self, other):
14725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14726 
 
14727 
  def __ne__(self, other):
14728 
    return not (self == other)
14729 
 
4910 phani.kuma 14730 
class markOrdersAsPickedUp_result:
4410 rajveer 14731 
  """
14732 
  Attributes:
14733 
   - ex
14734 
  """
14735 
 
14736 
  thrift_spec = (
4910 phani.kuma 14737 
    None, # 0
4410 rajveer 14738 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14739 
  )
14740 
 
4910 phani.kuma 14741 
  def __init__(self, ex=None,):
4410 rajveer 14742 
    self.ex = ex
14743 
 
14744 
  def read(self, iprot):
14745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14747 
      return
14748 
    iprot.readStructBegin()
14749 
    while True:
14750 
      (fname, ftype, fid) = iprot.readFieldBegin()
14751 
      if ftype == TType.STOP:
14752 
        break
4910 phani.kuma 14753 
      if fid == 1:
4410 rajveer 14754 
        if ftype == TType.STRUCT:
14755 
          self.ex = TransactionServiceException()
14756 
          self.ex.read(iprot)
14757 
        else:
14758 
          iprot.skip(ftype)
14759 
      else:
14760 
        iprot.skip(ftype)
14761 
      iprot.readFieldEnd()
14762 
    iprot.readStructEnd()
14763 
 
14764 
  def write(self, oprot):
14765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14767 
      return
4910 phani.kuma 14768 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14769 
    if self.ex is not None:
14770 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14771 
      self.ex.write(oprot)
14772 
      oprot.writeFieldEnd()
14773 
    oprot.writeFieldStop()
14774 
    oprot.writeStructEnd()
14775 
 
14776 
  def validate(self):
14777 
    return
14778 
 
14779 
 
14780 
  def __repr__(self):
14781 
    L = ['%s=%r' % (key, value)
14782 
      for key, value in self.__dict__.iteritems()]
14783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14784 
 
14785 
  def __eq__(self, other):
14786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14787 
 
14788 
  def __ne__(self, other):
14789 
    return not (self == other)
14790 
 
4910 phani.kuma 14791 
class getOrdersNotPickedUp_args:
304 ashish 14792 
  """
14793 
  Attributes:
3064 chandransh 14794 
   - providerId
304 ashish 14795 
  """
94 ashish 14796 
 
304 ashish 14797 
  thrift_spec = (
14798 
    None, # 0
3064 chandransh 14799 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14800 
  )
14801 
 
4910 phani.kuma 14802 
  def __init__(self, providerId=None,):
3064 chandransh 14803 
    self.providerId = providerId
304 ashish 14804 
 
14805 
  def read(self, iprot):
14806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14808 
      return
14809 
    iprot.readStructBegin()
14810 
    while True:
14811 
      (fname, ftype, fid) = iprot.readFieldBegin()
14812 
      if ftype == TType.STOP:
14813 
        break
14814 
      if fid == 1:
14815 
        if ftype == TType.I64:
3064 chandransh 14816 
          self.providerId = iprot.readI64();
304 ashish 14817 
        else:
14818 
          iprot.skip(ftype)
14819 
      else:
14820 
        iprot.skip(ftype)
14821 
      iprot.readFieldEnd()
14822 
    iprot.readStructEnd()
14823 
 
14824 
  def write(self, oprot):
14825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14827 
      return
4910 phani.kuma 14828 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14829 
    if self.providerId is not None:
3064 chandransh 14830 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14831 
      oprot.writeI64(self.providerId)
304 ashish 14832 
      oprot.writeFieldEnd()
14833 
    oprot.writeFieldStop()
14834 
    oprot.writeStructEnd()
14835 
 
3431 rajveer 14836 
  def validate(self):
14837 
    return
14838 
 
14839 
 
304 ashish 14840 
  def __repr__(self):
14841 
    L = ['%s=%r' % (key, value)
14842 
      for key, value in self.__dict__.iteritems()]
14843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14844 
 
14845 
  def __eq__(self, other):
14846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14847 
 
14848 
  def __ne__(self, other):
14849 
    return not (self == other)
14850 
 
4910 phani.kuma 14851 
class getOrdersNotPickedUp_result:
304 ashish 14852 
  """
14853 
  Attributes:
14854 
   - success
14855 
  """
14856 
 
14857 
  thrift_spec = (
3064 chandransh 14858 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14859 
  )
14860 
 
4910 phani.kuma 14861 
  def __init__(self, success=None,):
304 ashish 14862 
    self.success = success
14863 
 
14864 
  def read(self, iprot):
14865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14867 
      return
14868 
    iprot.readStructBegin()
14869 
    while True:
14870 
      (fname, ftype, fid) = iprot.readFieldBegin()
14871 
      if ftype == TType.STOP:
14872 
        break
14873 
      if fid == 0:
14874 
        if ftype == TType.LIST:
14875 
          self.success = []
6188 rajveer 14876 
          (_etype314, _size311) = iprot.readListBegin()
14877 
          for _i315 in xrange(_size311):
14878 
            _elem316 = Order()
14879 
            _elem316.read(iprot)
14880 
            self.success.append(_elem316)
304 ashish 14881 
          iprot.readListEnd()
14882 
        else:
14883 
          iprot.skip(ftype)
14884 
      else:
14885 
        iprot.skip(ftype)
14886 
      iprot.readFieldEnd()
14887 
    iprot.readStructEnd()
14888 
 
14889 
  def write(self, oprot):
14890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14892 
      return
4910 phani.kuma 14893 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14894 
    if self.success is not None:
304 ashish 14895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14896 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14897 
      for iter317 in self.success:
14898 
        iter317.write(oprot)
304 ashish 14899 
      oprot.writeListEnd()
14900 
      oprot.writeFieldEnd()
14901 
    oprot.writeFieldStop()
14902 
    oprot.writeStructEnd()
14903 
 
3431 rajveer 14904 
  def validate(self):
14905 
    return
14906 
 
14907 
 
304 ashish 14908 
  def __repr__(self):
14909 
    L = ['%s=%r' % (key, value)
14910 
      for key, value in self.__dict__.iteritems()]
14911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14912 
 
14913 
  def __eq__(self, other):
14914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14915 
 
14916 
  def __ne__(self, other):
14917 
    return not (self == other)
14918 
 
3064 chandransh 14919 
class markOrdersAsDelivered_args:
304 ashish 14920 
  """
14921 
  Attributes:
3064 chandransh 14922 
   - providerId
14923 
   - deliveredOrders
304 ashish 14924 
  """
14925 
 
14926 
  thrift_spec = (
14927 
    None, # 0
3064 chandransh 14928 
    (1, TType.I64, 'providerId', None, None, ), # 1
14929 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14930 
  )
14931 
 
3064 chandransh 14932 
  def __init__(self, providerId=None, deliveredOrders=None,):
14933 
    self.providerId = providerId
14934 
    self.deliveredOrders = deliveredOrders
304 ashish 14935 
 
14936 
  def read(self, iprot):
14937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14939 
      return
14940 
    iprot.readStructBegin()
14941 
    while True:
14942 
      (fname, ftype, fid) = iprot.readFieldBegin()
14943 
      if ftype == TType.STOP:
14944 
        break
14945 
      if fid == 1:
14946 
        if ftype == TType.I64:
3064 chandransh 14947 
          self.providerId = iprot.readI64();
304 ashish 14948 
        else:
14949 
          iprot.skip(ftype)
14950 
      elif fid == 2:
3064 chandransh 14951 
        if ftype == TType.MAP:
14952 
          self.deliveredOrders = {}
6188 rajveer 14953 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14954 
          for _i322 in xrange(_size318):
14955 
            _key323 = iprot.readString();
14956 
            _val324 = iprot.readString();
14957 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14958 
          iprot.readMapEnd()
304 ashish 14959 
        else:
14960 
          iprot.skip(ftype)
14961 
      else:
14962 
        iprot.skip(ftype)
14963 
      iprot.readFieldEnd()
14964 
    iprot.readStructEnd()
14965 
 
14966 
  def write(self, oprot):
14967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14969 
      return
3064 chandransh 14970 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14971 
    if self.providerId is not None:
3064 chandransh 14972 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14973 
      oprot.writeI64(self.providerId)
304 ashish 14974 
      oprot.writeFieldEnd()
3431 rajveer 14975 
    if self.deliveredOrders is not None:
3064 chandransh 14976 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14977 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14978 
      for kiter325,viter326 in self.deliveredOrders.items():
14979 
        oprot.writeString(kiter325)
14980 
        oprot.writeString(viter326)
3064 chandransh 14981 
      oprot.writeMapEnd()
304 ashish 14982 
      oprot.writeFieldEnd()
14983 
    oprot.writeFieldStop()
14984 
    oprot.writeStructEnd()
14985 
 
3431 rajveer 14986 
  def validate(self):
14987 
    return
14988 
 
14989 
 
304 ashish 14990 
  def __repr__(self):
14991 
    L = ['%s=%r' % (key, value)
14992 
      for key, value in self.__dict__.iteritems()]
14993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14994 
 
14995 
  def __eq__(self, other):
14996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14997 
 
14998 
  def __ne__(self, other):
14999 
    return not (self == other)
15000 
 
3064 chandransh 15001 
class markOrdersAsDelivered_result:
15002 
  """
15003 
  Attributes:
15004 
   - ex
15005 
  """
304 ashish 15006 
 
15007 
  thrift_spec = (
3064 chandransh 15008 
    None, # 0
15009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15010 
  )
15011 
 
3064 chandransh 15012 
  def __init__(self, ex=None,):
15013 
    self.ex = ex
304 ashish 15014 
 
1596 ankur.sing 15015 
  def read(self, iprot):
15016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15018 
      return
15019 
    iprot.readStructBegin()
15020 
    while True:
15021 
      (fname, ftype, fid) = iprot.readFieldBegin()
15022 
      if ftype == TType.STOP:
15023 
        break
3064 chandransh 15024 
      if fid == 1:
15025 
        if ftype == TType.STRUCT:
15026 
          self.ex = TransactionServiceException()
15027 
          self.ex.read(iprot)
15028 
        else:
15029 
          iprot.skip(ftype)
1596 ankur.sing 15030 
      else:
15031 
        iprot.skip(ftype)
15032 
      iprot.readFieldEnd()
15033 
    iprot.readStructEnd()
15034 
 
15035 
  def write(self, oprot):
15036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15038 
      return
3064 chandransh 15039 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15040 
    if self.ex is not None:
3064 chandransh 15041 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15042 
      self.ex.write(oprot)
15043 
      oprot.writeFieldEnd()
1596 ankur.sing 15044 
    oprot.writeFieldStop()
15045 
    oprot.writeStructEnd()
15046 
 
3431 rajveer 15047 
  def validate(self):
15048 
    return
15049 
 
15050 
 
1596 ankur.sing 15051 
  def __repr__(self):
15052 
    L = ['%s=%r' % (key, value)
15053 
      for key, value in self.__dict__.iteritems()]
15054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15055 
 
15056 
  def __eq__(self, other):
15057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15058 
 
15059 
  def __ne__(self, other):
15060 
    return not (self == other)
15061 
 
4910 phani.kuma 15062 
class markAsRTOrders_args:
1596 ankur.sing 15063 
  """
15064 
  Attributes:
3064 chandransh 15065 
   - providerId
15066 
   - returnedOrders
1596 ankur.sing 15067 
  """
15068 
 
15069 
  thrift_spec = (
3064 chandransh 15070 
    None, # 0
15071 
    (1, TType.I64, 'providerId', None, None, ), # 1
15072 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15073 
  )
15074 
 
3064 chandransh 15075 
  def __init__(self, providerId=None, returnedOrders=None,):
15076 
    self.providerId = providerId
15077 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15078 
 
15079 
  def read(self, iprot):
15080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15082 
      return
15083 
    iprot.readStructBegin()
15084 
    while True:
15085 
      (fname, ftype, fid) = iprot.readFieldBegin()
15086 
      if ftype == TType.STOP:
15087 
        break
3064 chandransh 15088 
      if fid == 1:
1596 ankur.sing 15089 
        if ftype == TType.I64:
3064 chandransh 15090 
          self.providerId = iprot.readI64();
1596 ankur.sing 15091 
        else:
15092 
          iprot.skip(ftype)
3064 chandransh 15093 
      elif fid == 2:
15094 
        if ftype == TType.MAP:
15095 
          self.returnedOrders = {}
6188 rajveer 15096 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15097 
          for _i331 in xrange(_size327):
15098 
            _key332 = iprot.readString();
15099 
            _val333 = iprot.readString();
15100 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15101 
          iprot.readMapEnd()
15102 
        else:
15103 
          iprot.skip(ftype)
1596 ankur.sing 15104 
      else:
15105 
        iprot.skip(ftype)
15106 
      iprot.readFieldEnd()
15107 
    iprot.readStructEnd()
15108 
 
15109 
  def write(self, oprot):
15110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15112 
      return
4910 phani.kuma 15113 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15114 
    if self.providerId is not None:
3064 chandransh 15115 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15116 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15117 
      oprot.writeFieldEnd()
3431 rajveer 15118 
    if self.returnedOrders is not None:
3064 chandransh 15119 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15120 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15121 
      for kiter334,viter335 in self.returnedOrders.items():
15122 
        oprot.writeString(kiter334)
15123 
        oprot.writeString(viter335)
3064 chandransh 15124 
      oprot.writeMapEnd()
15125 
      oprot.writeFieldEnd()
1596 ankur.sing 15126 
    oprot.writeFieldStop()
15127 
    oprot.writeStructEnd()
15128 
 
3431 rajveer 15129 
  def validate(self):
15130 
    return
15131 
 
15132 
 
1596 ankur.sing 15133 
  def __repr__(self):
15134 
    L = ['%s=%r' % (key, value)
15135 
      for key, value in self.__dict__.iteritems()]
15136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15137 
 
15138 
  def __eq__(self, other):
15139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15140 
 
15141 
  def __ne__(self, other):
15142 
    return not (self == other)
15143 
 
4910 phani.kuma 15144 
class markAsRTOrders_result:
3064 chandransh 15145 
  """
15146 
  Attributes:
15147 
   - ex
15148 
  """
1596 ankur.sing 15149 
 
1627 ankur.sing 15150 
  thrift_spec = (
3064 chandransh 15151 
    None, # 0
15152 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15153 
  )
15154 
 
3064 chandransh 15155 
  def __init__(self, ex=None,):
15156 
    self.ex = ex
15157 
 
1627 ankur.sing 15158 
  def read(self, iprot):
15159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15161 
      return
15162 
    iprot.readStructBegin()
15163 
    while True:
15164 
      (fname, ftype, fid) = iprot.readFieldBegin()
15165 
      if ftype == TType.STOP:
15166 
        break
3064 chandransh 15167 
      if fid == 1:
15168 
        if ftype == TType.STRUCT:
15169 
          self.ex = TransactionServiceException()
15170 
          self.ex.read(iprot)
15171 
        else:
15172 
          iprot.skip(ftype)
1627 ankur.sing 15173 
      else:
15174 
        iprot.skip(ftype)
15175 
      iprot.readFieldEnd()
15176 
    iprot.readStructEnd()
15177 
 
15178 
  def write(self, oprot):
15179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15181 
      return
4910 phani.kuma 15182 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15183 
    if self.ex is not None:
3064 chandransh 15184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15185 
      self.ex.write(oprot)
15186 
      oprot.writeFieldEnd()
1627 ankur.sing 15187 
    oprot.writeFieldStop()
15188 
    oprot.writeStructEnd()
15189 
 
3431 rajveer 15190 
  def validate(self):
15191 
    return
15192 
 
15193 
 
1627 ankur.sing 15194 
  def __repr__(self):
15195 
    L = ['%s=%r' % (key, value)
15196 
      for key, value in self.__dict__.iteritems()]
15197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15198 
 
15199 
  def __eq__(self, other):
15200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15201 
 
15202 
  def __ne__(self, other):
15203 
    return not (self == other)
15204 
 
4910 phani.kuma 15205 
class getRTOrders_args:
15206 
  """
15207 
  Attributes:
15208 
   - providerId
15209 
  """
15210 
 
15211 
  thrift_spec = (
15212 
    None, # 0
15213 
    (1, TType.I64, 'providerId', None, None, ), # 1
15214 
  )
15215 
 
15216 
  def __init__(self, providerId=None,):
15217 
    self.providerId = providerId
15218 
 
15219 
  def read(self, iprot):
15220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15222 
      return
15223 
    iprot.readStructBegin()
15224 
    while True:
15225 
      (fname, ftype, fid) = iprot.readFieldBegin()
15226 
      if ftype == TType.STOP:
15227 
        break
15228 
      if fid == 1:
15229 
        if ftype == TType.I64:
15230 
          self.providerId = iprot.readI64();
15231 
        else:
15232 
          iprot.skip(ftype)
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
15242 
    oprot.writeStructBegin('getRTOrders_args')
15243 
    if self.providerId is not None:
15244 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15245 
      oprot.writeI64(self.providerId)
15246 
      oprot.writeFieldEnd()
15247 
    oprot.writeFieldStop()
15248 
    oprot.writeStructEnd()
15249 
 
15250 
  def validate(self):
15251 
    return
15252 
 
15253 
 
15254 
  def __repr__(self):
15255 
    L = ['%s=%r' % (key, value)
15256 
      for key, value in self.__dict__.iteritems()]
15257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15258 
 
15259 
  def __eq__(self, other):
15260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15261 
 
15262 
  def __ne__(self, other):
15263 
    return not (self == other)
15264 
 
15265 
class getRTOrders_result:
15266 
  """
15267 
  Attributes:
15268 
   - success
15269 
  """
15270 
 
15271 
  thrift_spec = (
15272 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15273 
  )
15274 
 
15275 
  def __init__(self, success=None,):
15276 
    self.success = success
15277 
 
15278 
  def read(self, iprot):
15279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15281 
      return
15282 
    iprot.readStructBegin()
15283 
    while True:
15284 
      (fname, ftype, fid) = iprot.readFieldBegin()
15285 
      if ftype == TType.STOP:
15286 
        break
15287 
      if fid == 0:
15288 
        if ftype == TType.LIST:
15289 
          self.success = []
6188 rajveer 15290 
          (_etype339, _size336) = iprot.readListBegin()
15291 
          for _i340 in xrange(_size336):
15292 
            _elem341 = Order()
15293 
            _elem341.read(iprot)
15294 
            self.success.append(_elem341)
4910 phani.kuma 15295 
          iprot.readListEnd()
15296 
        else:
15297 
          iprot.skip(ftype)
15298 
      else:
15299 
        iprot.skip(ftype)
15300 
      iprot.readFieldEnd()
15301 
    iprot.readStructEnd()
15302 
 
15303 
  def write(self, oprot):
15304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15306 
      return
15307 
    oprot.writeStructBegin('getRTOrders_result')
15308 
    if self.success is not None:
15309 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15310 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15311 
      for iter342 in self.success:
15312 
        iter342.write(oprot)
4910 phani.kuma 15313 
      oprot.writeListEnd()
15314 
      oprot.writeFieldEnd()
15315 
    oprot.writeFieldStop()
15316 
    oprot.writeStructEnd()
15317 
 
15318 
  def validate(self):
15319 
    return
15320 
 
15321 
 
15322 
  def __repr__(self):
15323 
    L = ['%s=%r' % (key, value)
15324 
      for key, value in self.__dict__.iteritems()]
15325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15326 
 
15327 
  def __eq__(self, other):
15328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15329 
 
15330 
  def __ne__(self, other):
15331 
    return not (self == other)
15332 
 
3064 chandransh 15333 
class updateNonDeliveryReason_args:
1627 ankur.sing 15334 
  """
15335 
  Attributes:
3064 chandransh 15336 
   - providerId
15337 
   - undeliveredOrders
1627 ankur.sing 15338 
  """
15339 
 
15340 
  thrift_spec = (
3064 chandransh 15341 
    None, # 0
15342 
    (1, TType.I64, 'providerId', None, None, ), # 1
15343 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15344 
  )
15345 
 
3064 chandransh 15346 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15347 
    self.providerId = providerId
15348 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15349 
 
15350 
  def read(self, iprot):
15351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15353 
      return
15354 
    iprot.readStructBegin()
15355 
    while True:
15356 
      (fname, ftype, fid) = iprot.readFieldBegin()
15357 
      if ftype == TType.STOP:
15358 
        break
3064 chandransh 15359 
      if fid == 1:
1627 ankur.sing 15360 
        if ftype == TType.I64:
3064 chandransh 15361 
          self.providerId = iprot.readI64();
1627 ankur.sing 15362 
        else:
15363 
          iprot.skip(ftype)
3064 chandransh 15364 
      elif fid == 2:
15365 
        if ftype == TType.MAP:
15366 
          self.undeliveredOrders = {}
6188 rajveer 15367 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15368 
          for _i347 in xrange(_size343):
15369 
            _key348 = iprot.readString();
15370 
            _val349 = iprot.readString();
15371 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15372 
          iprot.readMapEnd()
15373 
        else:
15374 
          iprot.skip(ftype)
1627 ankur.sing 15375 
      else:
15376 
        iprot.skip(ftype)
15377 
      iprot.readFieldEnd()
15378 
    iprot.readStructEnd()
15379 
 
15380 
  def write(self, oprot):
15381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15383 
      return
3064 chandransh 15384 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15385 
    if self.providerId is not None:
3064 chandransh 15386 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15387 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15388 
      oprot.writeFieldEnd()
3431 rajveer 15389 
    if self.undeliveredOrders is not None:
3064 chandransh 15390 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15391 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15392 
      for kiter350,viter351 in self.undeliveredOrders.items():
15393 
        oprot.writeString(kiter350)
15394 
        oprot.writeString(viter351)
3064 chandransh 15395 
      oprot.writeMapEnd()
15396 
      oprot.writeFieldEnd()
1627 ankur.sing 15397 
    oprot.writeFieldStop()
15398 
    oprot.writeStructEnd()
15399 
 
3431 rajveer 15400 
  def validate(self):
15401 
    return
15402 
 
15403 
 
1627 ankur.sing 15404 
  def __repr__(self):
15405 
    L = ['%s=%r' % (key, value)
15406 
      for key, value in self.__dict__.iteritems()]
15407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15408 
 
15409 
  def __eq__(self, other):
15410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15411 
 
15412 
  def __ne__(self, other):
15413 
    return not (self == other)
15414 
 
3064 chandransh 15415 
class updateNonDeliveryReason_result:
1627 ankur.sing 15416 
  """
15417 
  Attributes:
3064 chandransh 15418 
   - ex
1627 ankur.sing 15419 
  """
15420 
 
15421 
  thrift_spec = (
4910 phani.kuma 15422 
    None, # 0
3064 chandransh 15423 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15424 
  )
15425 
 
4910 phani.kuma 15426 
  def __init__(self, ex=None,):
3064 chandransh 15427 
    self.ex = ex
1627 ankur.sing 15428 
 
15429 
  def read(self, iprot):
15430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15432 
      return
15433 
    iprot.readStructBegin()
15434 
    while True:
15435 
      (fname, ftype, fid) = iprot.readFieldBegin()
15436 
      if ftype == TType.STOP:
15437 
        break
4910 phani.kuma 15438 
      if fid == 1:
15439 
        if ftype == TType.STRUCT:
15440 
          self.ex = TransactionServiceException()
15441 
          self.ex.read(iprot)
15442 
        else:
15443 
          iprot.skip(ftype)
15444 
      else:
15445 
        iprot.skip(ftype)
15446 
      iprot.readFieldEnd()
15447 
    iprot.readStructEnd()
15448 
 
15449 
  def write(self, oprot):
15450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15452 
      return
15453 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15454 
    if self.ex is not None:
15455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15456 
      self.ex.write(oprot)
15457 
      oprot.writeFieldEnd()
15458 
    oprot.writeFieldStop()
15459 
    oprot.writeStructEnd()
15460 
 
15461 
  def validate(self):
15462 
    return
15463 
 
15464 
 
15465 
  def __repr__(self):
15466 
    L = ['%s=%r' % (key, value)
15467 
      for key, value in self.__dict__.iteritems()]
15468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15469 
 
15470 
  def __eq__(self, other):
15471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15472 
 
15473 
  def __ne__(self, other):
15474 
    return not (self == other)
15475 
 
15476 
class getNonDeliveredOrdersbyCourier_args:
15477 
  """
15478 
  Attributes:
15479 
   - providerId
15480 
  """
15481 
 
15482 
  thrift_spec = (
15483 
    None, # 0
15484 
    (1, TType.I64, 'providerId', None, None, ), # 1
15485 
  )
15486 
 
15487 
  def __init__(self, providerId=None,):
15488 
    self.providerId = providerId
15489 
 
15490 
  def read(self, iprot):
15491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15493 
      return
15494 
    iprot.readStructBegin()
15495 
    while True:
15496 
      (fname, ftype, fid) = iprot.readFieldBegin()
15497 
      if ftype == TType.STOP:
15498 
        break
15499 
      if fid == 1:
15500 
        if ftype == TType.I64:
15501 
          self.providerId = iprot.readI64();
15502 
        else:
15503 
          iprot.skip(ftype)
15504 
      else:
15505 
        iprot.skip(ftype)
15506 
      iprot.readFieldEnd()
15507 
    iprot.readStructEnd()
15508 
 
15509 
  def write(self, oprot):
15510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15512 
      return
15513 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15514 
    if self.providerId is not None:
15515 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15516 
      oprot.writeI64(self.providerId)
15517 
      oprot.writeFieldEnd()
15518 
    oprot.writeFieldStop()
15519 
    oprot.writeStructEnd()
15520 
 
15521 
  def validate(self):
15522 
    return
15523 
 
15524 
 
15525 
  def __repr__(self):
15526 
    L = ['%s=%r' % (key, value)
15527 
      for key, value in self.__dict__.iteritems()]
15528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15529 
 
15530 
  def __eq__(self, other):
15531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15532 
 
15533 
  def __ne__(self, other):
15534 
    return not (self == other)
15535 
 
15536 
class getNonDeliveredOrdersbyCourier_result:
15537 
  """
15538 
  Attributes:
15539 
   - success
15540 
  """
15541 
 
15542 
  thrift_spec = (
15543 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15544 
  )
15545 
 
15546 
  def __init__(self, success=None,):
15547 
    self.success = success
15548 
 
15549 
  def read(self, iprot):
15550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15552 
      return
15553 
    iprot.readStructBegin()
15554 
    while True:
15555 
      (fname, ftype, fid) = iprot.readFieldBegin()
15556 
      if ftype == TType.STOP:
15557 
        break
4581 phani.kuma 15558 
      if fid == 0:
15559 
        if ftype == TType.LIST:
15560 
          self.success = []
6188 rajveer 15561 
          (_etype355, _size352) = iprot.readListBegin()
15562 
          for _i356 in xrange(_size352):
15563 
            _elem357 = Order()
15564 
            _elem357.read(iprot)
15565 
            self.success.append(_elem357)
4581 phani.kuma 15566 
          iprot.readListEnd()
15567 
        else:
15568 
          iprot.skip(ftype)
4910 phani.kuma 15569 
      else:
15570 
        iprot.skip(ftype)
15571 
      iprot.readFieldEnd()
15572 
    iprot.readStructEnd()
15573 
 
15574 
  def write(self, oprot):
15575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15577 
      return
15578 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15579 
    if self.success is not None:
15580 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15581 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15582 
      for iter358 in self.success:
15583 
        iter358.write(oprot)
4910 phani.kuma 15584 
      oprot.writeListEnd()
15585 
      oprot.writeFieldEnd()
15586 
    oprot.writeFieldStop()
15587 
    oprot.writeStructEnd()
15588 
 
15589 
  def validate(self):
15590 
    return
15591 
 
15592 
 
15593 
  def __repr__(self):
15594 
    L = ['%s=%r' % (key, value)
15595 
      for key, value in self.__dict__.iteritems()]
15596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15597 
 
15598 
  def __eq__(self, other):
15599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15600 
 
15601 
  def __ne__(self, other):
15602 
    return not (self == other)
15603 
 
15604 
class markOrdersAsLocalConnected_args:
15605 
  """
15606 
  Attributes:
15607 
   - providerId
15608 
   - local_connected_orders
15609 
  """
15610 
 
15611 
  thrift_spec = (
15612 
    None, # 0
15613 
    (1, TType.I64, 'providerId', None, None, ), # 1
15614 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15615 
  )
15616 
 
15617 
  def __init__(self, providerId=None, local_connected_orders=None,):
15618 
    self.providerId = providerId
15619 
    self.local_connected_orders = local_connected_orders
15620 
 
15621 
  def read(self, iprot):
15622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15624 
      return
15625 
    iprot.readStructBegin()
15626 
    while True:
15627 
      (fname, ftype, fid) = iprot.readFieldBegin()
15628 
      if ftype == TType.STOP:
15629 
        break
15630 
      if fid == 1:
15631 
        if ftype == TType.I64:
15632 
          self.providerId = iprot.readI64();
15633 
        else:
15634 
          iprot.skip(ftype)
15635 
      elif fid == 2:
15636 
        if ftype == TType.MAP:
15637 
          self.local_connected_orders = {}
6188 rajveer 15638 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15639 
          for _i363 in xrange(_size359):
15640 
            _key364 = iprot.readString();
15641 
            _val365 = iprot.readString();
15642 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15643 
          iprot.readMapEnd()
15644 
        else:
15645 
          iprot.skip(ftype)
15646 
      else:
15647 
        iprot.skip(ftype)
15648 
      iprot.readFieldEnd()
15649 
    iprot.readStructEnd()
15650 
 
15651 
  def write(self, oprot):
15652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15654 
      return
15655 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15656 
    if self.providerId is not None:
15657 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15658 
      oprot.writeI64(self.providerId)
15659 
      oprot.writeFieldEnd()
15660 
    if self.local_connected_orders is not None:
15661 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15662 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15663 
      for kiter366,viter367 in self.local_connected_orders.items():
15664 
        oprot.writeString(kiter366)
15665 
        oprot.writeString(viter367)
4910 phani.kuma 15666 
      oprot.writeMapEnd()
15667 
      oprot.writeFieldEnd()
15668 
    oprot.writeFieldStop()
15669 
    oprot.writeStructEnd()
15670 
 
15671 
  def validate(self):
15672 
    return
15673 
 
15674 
 
15675 
  def __repr__(self):
15676 
    L = ['%s=%r' % (key, value)
15677 
      for key, value in self.__dict__.iteritems()]
15678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15679 
 
15680 
  def __eq__(self, other):
15681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15682 
 
15683 
  def __ne__(self, other):
15684 
    return not (self == other)
15685 
 
15686 
class markOrdersAsLocalConnected_result:
15687 
  """
15688 
  Attributes:
15689 
   - ex
15690 
  """
15691 
 
15692 
  thrift_spec = (
15693 
    None, # 0
15694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15695 
  )
15696 
 
15697 
  def __init__(self, ex=None,):
15698 
    self.ex = ex
15699 
 
15700 
  def read(self, iprot):
15701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15703 
      return
15704 
    iprot.readStructBegin()
15705 
    while True:
15706 
      (fname, ftype, fid) = iprot.readFieldBegin()
15707 
      if ftype == TType.STOP:
15708 
        break
15709 
      if fid == 1:
3064 chandransh 15710 
        if ftype == TType.STRUCT:
15711 
          self.ex = TransactionServiceException()
15712 
          self.ex.read(iprot)
1627 ankur.sing 15713 
        else:
15714 
          iprot.skip(ftype)
15715 
      else:
15716 
        iprot.skip(ftype)
15717 
      iprot.readFieldEnd()
15718 
    iprot.readStructEnd()
15719 
 
15720 
  def write(self, oprot):
15721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15723 
      return
4910 phani.kuma 15724 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15725 
    if self.ex is not None:
15726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15727 
      self.ex.write(oprot)
15728 
      oprot.writeFieldEnd()
15729 
    oprot.writeFieldStop()
15730 
    oprot.writeStructEnd()
15731 
 
15732 
  def validate(self):
15733 
    return
15734 
 
15735 
 
15736 
  def __repr__(self):
15737 
    L = ['%s=%r' % (key, value)
15738 
      for key, value in self.__dict__.iteritems()]
15739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15740 
 
15741 
  def __eq__(self, other):
15742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15743 
 
15744 
  def __ne__(self, other):
15745 
    return not (self == other)
15746 
 
15747 
class getOrdersNotLocalConnected_args:
15748 
  """
15749 
  Attributes:
15750 
   - providerId
15751 
  """
15752 
 
15753 
  thrift_spec = (
15754 
    None, # 0
15755 
    (1, TType.I64, 'providerId', None, None, ), # 1
15756 
  )
15757 
 
15758 
  def __init__(self, providerId=None,):
15759 
    self.providerId = providerId
15760 
 
15761 
  def read(self, iprot):
15762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15764 
      return
15765 
    iprot.readStructBegin()
15766 
    while True:
15767 
      (fname, ftype, fid) = iprot.readFieldBegin()
15768 
      if ftype == TType.STOP:
15769 
        break
15770 
      if fid == 1:
15771 
        if ftype == TType.I64:
15772 
          self.providerId = iprot.readI64();
15773 
        else:
15774 
          iprot.skip(ftype)
15775 
      else:
15776 
        iprot.skip(ftype)
15777 
      iprot.readFieldEnd()
15778 
    iprot.readStructEnd()
15779 
 
15780 
  def write(self, oprot):
15781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15783 
      return
15784 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15785 
    if self.providerId is not None:
15786 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15787 
      oprot.writeI64(self.providerId)
15788 
      oprot.writeFieldEnd()
15789 
    oprot.writeFieldStop()
15790 
    oprot.writeStructEnd()
15791 
 
15792 
  def validate(self):
15793 
    return
15794 
 
15795 
 
15796 
  def __repr__(self):
15797 
    L = ['%s=%r' % (key, value)
15798 
      for key, value in self.__dict__.iteritems()]
15799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15800 
 
15801 
  def __eq__(self, other):
15802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15803 
 
15804 
  def __ne__(self, other):
15805 
    return not (self == other)
15806 
 
15807 
class getOrdersNotLocalConnected_result:
15808 
  """
15809 
  Attributes:
15810 
   - success
15811 
  """
15812 
 
15813 
  thrift_spec = (
15814 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15815 
  )
15816 
 
15817 
  def __init__(self, success=None,):
15818 
    self.success = success
15819 
 
15820 
  def read(self, iprot):
15821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15823 
      return
15824 
    iprot.readStructBegin()
15825 
    while True:
15826 
      (fname, ftype, fid) = iprot.readFieldBegin()
15827 
      if ftype == TType.STOP:
15828 
        break
15829 
      if fid == 0:
15830 
        if ftype == TType.LIST:
15831 
          self.success = []
6188 rajveer 15832 
          (_etype371, _size368) = iprot.readListBegin()
15833 
          for _i372 in xrange(_size368):
15834 
            _elem373 = Order()
15835 
            _elem373.read(iprot)
15836 
            self.success.append(_elem373)
4910 phani.kuma 15837 
          iprot.readListEnd()
15838 
        else:
15839 
          iprot.skip(ftype)
15840 
      else:
15841 
        iprot.skip(ftype)
15842 
      iprot.readFieldEnd()
15843 
    iprot.readStructEnd()
15844 
 
15845 
  def write(self, oprot):
15846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15848 
      return
15849 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15850 
    if self.success is not None:
15851 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15852 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15853 
      for iter374 in self.success:
15854 
        iter374.write(oprot)
4581 phani.kuma 15855 
      oprot.writeListEnd()
15856 
      oprot.writeFieldEnd()
4910 phani.kuma 15857 
    oprot.writeFieldStop()
15858 
    oprot.writeStructEnd()
15859 
 
15860 
  def validate(self):
15861 
    return
15862 
 
15863 
 
15864 
  def __repr__(self):
15865 
    L = ['%s=%r' % (key, value)
15866 
      for key, value in self.__dict__.iteritems()]
15867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15868 
 
15869 
  def __eq__(self, other):
15870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15871 
 
15872 
  def __ne__(self, other):
15873 
    return not (self == other)
15874 
 
15875 
class markOrdersAsDestinationCityReached_args:
15876 
  """
15877 
  Attributes:
15878 
   - providerId
15879 
   - destination_city_reached_orders
15880 
  """
15881 
 
15882 
  thrift_spec = (
15883 
    None, # 0
15884 
    (1, TType.I64, 'providerId', None, None, ), # 1
15885 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15886 
  )
15887 
 
15888 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15889 
    self.providerId = providerId
15890 
    self.destination_city_reached_orders = destination_city_reached_orders
15891 
 
15892 
  def read(self, iprot):
15893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15895 
      return
15896 
    iprot.readStructBegin()
15897 
    while True:
15898 
      (fname, ftype, fid) = iprot.readFieldBegin()
15899 
      if ftype == TType.STOP:
15900 
        break
15901 
      if fid == 1:
15902 
        if ftype == TType.I64:
15903 
          self.providerId = iprot.readI64();
15904 
        else:
15905 
          iprot.skip(ftype)
15906 
      elif fid == 2:
15907 
        if ftype == TType.MAP:
15908 
          self.destination_city_reached_orders = {}
6188 rajveer 15909 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15910 
          for _i379 in xrange(_size375):
15911 
            _key380 = iprot.readString();
15912 
            _val381 = iprot.readString();
15913 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15914 
          iprot.readMapEnd()
15915 
        else:
15916 
          iprot.skip(ftype)
15917 
      else:
15918 
        iprot.skip(ftype)
15919 
      iprot.readFieldEnd()
15920 
    iprot.readStructEnd()
15921 
 
15922 
  def write(self, oprot):
15923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15925 
      return
15926 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15927 
    if self.providerId is not None:
15928 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15929 
      oprot.writeI64(self.providerId)
15930 
      oprot.writeFieldEnd()
15931 
    if self.destination_city_reached_orders is not None:
15932 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15933 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15934 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15935 
        oprot.writeString(kiter382)
15936 
        oprot.writeString(viter383)
4910 phani.kuma 15937 
      oprot.writeMapEnd()
15938 
      oprot.writeFieldEnd()
15939 
    oprot.writeFieldStop()
15940 
    oprot.writeStructEnd()
15941 
 
15942 
  def validate(self):
15943 
    return
15944 
 
15945 
 
15946 
  def __repr__(self):
15947 
    L = ['%s=%r' % (key, value)
15948 
      for key, value in self.__dict__.iteritems()]
15949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15950 
 
15951 
  def __eq__(self, other):
15952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15953 
 
15954 
  def __ne__(self, other):
15955 
    return not (self == other)
15956 
 
15957 
class markOrdersAsDestinationCityReached_result:
15958 
  """
15959 
  Attributes:
15960 
   - ex
15961 
  """
15962 
 
15963 
  thrift_spec = (
15964 
    None, # 0
15965 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15966 
  )
15967 
 
15968 
  def __init__(self, ex=None,):
15969 
    self.ex = ex
15970 
 
15971 
  def read(self, iprot):
15972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15974 
      return
15975 
    iprot.readStructBegin()
15976 
    while True:
15977 
      (fname, ftype, fid) = iprot.readFieldBegin()
15978 
      if ftype == TType.STOP:
15979 
        break
15980 
      if fid == 1:
15981 
        if ftype == TType.STRUCT:
15982 
          self.ex = TransactionServiceException()
15983 
          self.ex.read(iprot)
15984 
        else:
15985 
          iprot.skip(ftype)
15986 
      else:
15987 
        iprot.skip(ftype)
15988 
      iprot.readFieldEnd()
15989 
    iprot.readStructEnd()
15990 
 
15991 
  def write(self, oprot):
15992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15994 
      return
15995 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15996 
    if self.ex is not None:
3064 chandransh 15997 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15998 
      self.ex.write(oprot)
1627 ankur.sing 15999 
      oprot.writeFieldEnd()
16000 
    oprot.writeFieldStop()
16001 
    oprot.writeStructEnd()
16002 
 
3431 rajveer 16003 
  def validate(self):
16004 
    return
16005 
 
16006 
 
1627 ankur.sing 16007 
  def __repr__(self):
16008 
    L = ['%s=%r' % (key, value)
16009 
      for key, value in self.__dict__.iteritems()]
16010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16011 
 
16012 
  def __eq__(self, other):
16013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16014 
 
16015 
  def __ne__(self, other):
16016 
    return not (self == other)
16017 
 
4910 phani.kuma 16018 
class markOrdersAsFirstDeliveryAttempted_args:
16019 
  """
16020 
  Attributes:
16021 
   - providerId
16022 
   - first_atdl_orders
16023 
  """
16024 
 
16025 
  thrift_spec = (
16026 
    None, # 0
16027 
    (1, TType.I64, 'providerId', None, None, ), # 1
16028 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16029 
  )
16030 
 
16031 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16032 
    self.providerId = providerId
16033 
    self.first_atdl_orders = first_atdl_orders
16034 
 
16035 
  def read(self, iprot):
16036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16038 
      return
16039 
    iprot.readStructBegin()
16040 
    while True:
16041 
      (fname, ftype, fid) = iprot.readFieldBegin()
16042 
      if ftype == TType.STOP:
16043 
        break
16044 
      if fid == 1:
16045 
        if ftype == TType.I64:
16046 
          self.providerId = iprot.readI64();
16047 
        else:
16048 
          iprot.skip(ftype)
16049 
      elif fid == 2:
16050 
        if ftype == TType.MAP:
16051 
          self.first_atdl_orders = {}
6188 rajveer 16052 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16053 
          for _i388 in xrange(_size384):
16054 
            _key389 = iprot.readString();
16055 
            _val390 = iprot.readString();
16056 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16057 
          iprot.readMapEnd()
16058 
        else:
16059 
          iprot.skip(ftype)
16060 
      else:
16061 
        iprot.skip(ftype)
16062 
      iprot.readFieldEnd()
16063 
    iprot.readStructEnd()
16064 
 
16065 
  def write(self, oprot):
16066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16068 
      return
16069 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16070 
    if self.providerId is not None:
16071 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16072 
      oprot.writeI64(self.providerId)
16073 
      oprot.writeFieldEnd()
16074 
    if self.first_atdl_orders is not None:
16075 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16076 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16077 
      for kiter391,viter392 in self.first_atdl_orders.items():
16078 
        oprot.writeString(kiter391)
16079 
        oprot.writeString(viter392)
4910 phani.kuma 16080 
      oprot.writeMapEnd()
16081 
      oprot.writeFieldEnd()
16082 
    oprot.writeFieldStop()
16083 
    oprot.writeStructEnd()
16084 
 
16085 
  def validate(self):
16086 
    return
16087 
 
16088 
 
16089 
  def __repr__(self):
16090 
    L = ['%s=%r' % (key, value)
16091 
      for key, value in self.__dict__.iteritems()]
16092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16093 
 
16094 
  def __eq__(self, other):
16095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16096 
 
16097 
  def __ne__(self, other):
16098 
    return not (self == other)
16099 
 
16100 
class markOrdersAsFirstDeliveryAttempted_result:
16101 
  """
16102 
  Attributes:
16103 
   - ex
16104 
  """
16105 
 
16106 
  thrift_spec = (
16107 
    None, # 0
16108 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16109 
  )
16110 
 
16111 
  def __init__(self, ex=None,):
16112 
    self.ex = ex
16113 
 
16114 
  def read(self, iprot):
16115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16117 
      return
16118 
    iprot.readStructBegin()
16119 
    while True:
16120 
      (fname, ftype, fid) = iprot.readFieldBegin()
16121 
      if ftype == TType.STOP:
16122 
        break
16123 
      if fid == 1:
16124 
        if ftype == TType.STRUCT:
16125 
          self.ex = TransactionServiceException()
16126 
          self.ex.read(iprot)
16127 
        else:
16128 
          iprot.skip(ftype)
16129 
      else:
16130 
        iprot.skip(ftype)
16131 
      iprot.readFieldEnd()
16132 
    iprot.readStructEnd()
16133 
 
16134 
  def write(self, oprot):
16135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16137 
      return
16138 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16139 
    if self.ex is not None:
16140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16141 
      self.ex.write(oprot)
16142 
      oprot.writeFieldEnd()
16143 
    oprot.writeFieldStop()
16144 
    oprot.writeStructEnd()
16145 
 
16146 
  def validate(self):
16147 
    return
16148 
 
16149 
 
16150 
  def __repr__(self):
16151 
    L = ['%s=%r' % (key, value)
16152 
      for key, value in self.__dict__.iteritems()]
16153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16154 
 
16155 
  def __eq__(self, other):
16156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16157 
 
16158 
  def __ne__(self, other):
16159 
    return not (self == other)
16160 
 
3064 chandransh 16161 
class getUndeliveredOrders_args:
1886 ankur.sing 16162 
  """
16163 
  Attributes:
3064 chandransh 16164 
   - providerId
16165 
   - warehouseId
1886 ankur.sing 16166 
  """
1627 ankur.sing 16167 
 
1886 ankur.sing 16168 
  thrift_spec = (
16169 
    None, # 0
3064 chandransh 16170 
    (1, TType.I64, 'providerId', None, None, ), # 1
16171 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16172 
  )
16173 
 
3064 chandransh 16174 
  def __init__(self, providerId=None, warehouseId=None,):
16175 
    self.providerId = providerId
16176 
    self.warehouseId = warehouseId
1886 ankur.sing 16177 
 
16178 
  def read(self, iprot):
16179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16181 
      return
16182 
    iprot.readStructBegin()
16183 
    while True:
16184 
      (fname, ftype, fid) = iprot.readFieldBegin()
16185 
      if ftype == TType.STOP:
16186 
        break
16187 
      if fid == 1:
16188 
        if ftype == TType.I64:
3064 chandransh 16189 
          self.providerId = iprot.readI64();
1886 ankur.sing 16190 
        else:
16191 
          iprot.skip(ftype)
3064 chandransh 16192 
      elif fid == 2:
16193 
        if ftype == TType.I64:
16194 
          self.warehouseId = iprot.readI64();
16195 
        else:
16196 
          iprot.skip(ftype)
1886 ankur.sing 16197 
      else:
16198 
        iprot.skip(ftype)
16199 
      iprot.readFieldEnd()
16200 
    iprot.readStructEnd()
16201 
 
16202 
  def write(self, oprot):
16203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16205 
      return
3064 chandransh 16206 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16207 
    if self.providerId is not None:
3064 chandransh 16208 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16209 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16210 
      oprot.writeFieldEnd()
3431 rajveer 16211 
    if self.warehouseId is not None:
3064 chandransh 16212 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16213 
      oprot.writeI64(self.warehouseId)
16214 
      oprot.writeFieldEnd()
1886 ankur.sing 16215 
    oprot.writeFieldStop()
16216 
    oprot.writeStructEnd()
16217 
 
3431 rajveer 16218 
  def validate(self):
16219 
    return
16220 
 
16221 
 
1886 ankur.sing 16222 
  def __repr__(self):
16223 
    L = ['%s=%r' % (key, value)
16224 
      for key, value in self.__dict__.iteritems()]
16225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16226 
 
16227 
  def __eq__(self, other):
16228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16229 
 
16230 
  def __ne__(self, other):
16231 
    return not (self == other)
16232 
 
3064 chandransh 16233 
class getUndeliveredOrders_result:
1886 ankur.sing 16234 
  """
16235 
  Attributes:
16236 
   - success
16237 
  """
16238 
 
16239 
  thrift_spec = (
16240 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16241 
  )
16242 
 
16243 
  def __init__(self, success=None,):
16244 
    self.success = success
16245 
 
16246 
  def read(self, iprot):
16247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16249 
      return
16250 
    iprot.readStructBegin()
16251 
    while True:
16252 
      (fname, ftype, fid) = iprot.readFieldBegin()
16253 
      if ftype == TType.STOP:
16254 
        break
16255 
      if fid == 0:
16256 
        if ftype == TType.LIST:
16257 
          self.success = []
6188 rajveer 16258 
          (_etype396, _size393) = iprot.readListBegin()
16259 
          for _i397 in xrange(_size393):
16260 
            _elem398 = Order()
16261 
            _elem398.read(iprot)
16262 
            self.success.append(_elem398)
1886 ankur.sing 16263 
          iprot.readListEnd()
16264 
        else:
16265 
          iprot.skip(ftype)
16266 
      else:
16267 
        iprot.skip(ftype)
16268 
      iprot.readFieldEnd()
16269 
    iprot.readStructEnd()
16270 
 
16271 
  def write(self, oprot):
16272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16274 
      return
3064 chandransh 16275 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16276 
    if self.success is not None:
1886 ankur.sing 16277 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16278 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16279 
      for iter399 in self.success:
16280 
        iter399.write(oprot)
1886 ankur.sing 16281 
      oprot.writeListEnd()
16282 
      oprot.writeFieldEnd()
16283 
    oprot.writeFieldStop()
16284 
    oprot.writeStructEnd()
16285 
 
3431 rajveer 16286 
  def validate(self):
16287 
    return
16288 
 
16289 
 
1886 ankur.sing 16290 
  def __repr__(self):
16291 
    L = ['%s=%r' % (key, value)
16292 
      for key, value in self.__dict__.iteritems()]
16293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16294 
 
16295 
  def __eq__(self, other):
16296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16297 
 
16298 
  def __ne__(self, other):
16299 
    return not (self == other)
16300 
 
4783 phani.kuma 16301 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16302 
 
16303 
  thrift_spec = (
16304 
  )
16305 
 
16306 
  def read(self, iprot):
16307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16309 
      return
16310 
    iprot.readStructBegin()
16311 
    while True:
16312 
      (fname, ftype, fid) = iprot.readFieldBegin()
16313 
      if ftype == TType.STOP:
16314 
        break
16315 
      else:
16316 
        iprot.skip(ftype)
16317 
      iprot.readFieldEnd()
16318 
    iprot.readStructEnd()
16319 
 
16320 
  def write(self, oprot):
16321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16323 
      return
16324 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16325 
    oprot.writeFieldStop()
16326 
    oprot.writeStructEnd()
16327 
 
16328 
  def validate(self):
16329 
    return
16330 
 
16331 
 
16332 
  def __repr__(self):
16333 
    L = ['%s=%r' % (key, value)
16334 
      for key, value in self.__dict__.iteritems()]
16335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16336 
 
16337 
  def __eq__(self, other):
16338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16339 
 
16340 
  def __ne__(self, other):
16341 
    return not (self == other)
16342 
 
16343 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16344 
  """
16345 
  Attributes:
16346 
   - success
16347 
  """
16348 
 
16349 
  thrift_spec = (
16350 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16351 
  )
16352 
 
16353 
  def __init__(self, success=None,):
16354 
    self.success = success
16355 
 
16356 
  def read(self, iprot):
16357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16359 
      return
16360 
    iprot.readStructBegin()
16361 
    while True:
16362 
      (fname, ftype, fid) = iprot.readFieldBegin()
16363 
      if ftype == TType.STOP:
16364 
        break
16365 
      if fid == 0:
16366 
        if ftype == TType.LIST:
16367 
          self.success = []
6188 rajveer 16368 
          (_etype403, _size400) = iprot.readListBegin()
16369 
          for _i404 in xrange(_size400):
16370 
            _elem405 = Order()
16371 
            _elem405.read(iprot)
16372 
            self.success.append(_elem405)
4783 phani.kuma 16373 
          iprot.readListEnd()
16374 
        else:
16375 
          iprot.skip(ftype)
16376 
      else:
16377 
        iprot.skip(ftype)
16378 
      iprot.readFieldEnd()
16379 
    iprot.readStructEnd()
16380 
 
16381 
  def write(self, oprot):
16382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16384 
      return
16385 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16386 
    if self.success is not None:
16387 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16388 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16389 
      for iter406 in self.success:
16390 
        iter406.write(oprot)
4783 phani.kuma 16391 
      oprot.writeListEnd()
16392 
      oprot.writeFieldEnd()
16393 
    oprot.writeFieldStop()
16394 
    oprot.writeStructEnd()
16395 
 
16396 
  def validate(self):
16397 
    return
16398 
 
16399 
 
16400 
  def __repr__(self):
16401 
    L = ['%s=%r' % (key, value)
16402 
      for key, value in self.__dict__.iteritems()]
16403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16404 
 
16405 
  def __eq__(self, other):
16406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16407 
 
16408 
  def __ne__(self, other):
16409 
    return not (self == other)
16410 
 
2536 chandransh 16411 
class toggleDOAFlag_args:
16412 
  """
16413 
  Attributes:
16414 
   - orderId
16415 
  """
1886 ankur.sing 16416 
 
2536 chandransh 16417 
  thrift_spec = (
16418 
    None, # 0
16419 
    (1, TType.I64, 'orderId', None, None, ), # 1
16420 
  )
16421 
 
16422 
  def __init__(self, orderId=None,):
16423 
    self.orderId = orderId
16424 
 
16425 
  def read(self, iprot):
16426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16428 
      return
16429 
    iprot.readStructBegin()
16430 
    while True:
16431 
      (fname, ftype, fid) = iprot.readFieldBegin()
16432 
      if ftype == TType.STOP:
16433 
        break
16434 
      if fid == 1:
16435 
        if ftype == TType.I64:
16436 
          self.orderId = iprot.readI64();
16437 
        else:
16438 
          iprot.skip(ftype)
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('toggleDOAFlag_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()
16453 
    oprot.writeFieldStop()
16454 
    oprot.writeStructEnd()
16455 
 
3431 rajveer 16456 
  def validate(self):
16457 
    return
16458 
 
16459 
 
2536 chandransh 16460 
  def __repr__(self):
16461 
    L = ['%s=%r' % (key, value)
16462 
      for key, value in self.__dict__.iteritems()]
16463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16464 
 
16465 
  def __eq__(self, other):
16466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16467 
 
16468 
  def __ne__(self, other):
16469 
    return not (self == other)
16470 
 
16471 
class toggleDOAFlag_result:
16472 
  """
16473 
  Attributes:
16474 
   - success
16475 
   - ex
16476 
  """
16477 
 
16478 
  thrift_spec = (
16479 
    (0, TType.BOOL, 'success', None, None, ), # 0
16480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16481 
  )
16482 
 
16483 
  def __init__(self, success=None, ex=None,):
16484 
    self.success = success
16485 
    self.ex = ex
16486 
 
16487 
  def read(self, iprot):
16488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16490 
      return
16491 
    iprot.readStructBegin()
16492 
    while True:
16493 
      (fname, ftype, fid) = iprot.readFieldBegin()
16494 
      if ftype == TType.STOP:
16495 
        break
16496 
      if fid == 0:
16497 
        if ftype == TType.BOOL:
16498 
          self.success = iprot.readBool();
16499 
        else:
16500 
          iprot.skip(ftype)
16501 
      elif fid == 1:
16502 
        if ftype == TType.STRUCT:
16503 
          self.ex = TransactionServiceException()
16504 
          self.ex.read(iprot)
16505 
        else:
16506 
          iprot.skip(ftype)
16507 
      else:
16508 
        iprot.skip(ftype)
16509 
      iprot.readFieldEnd()
16510 
    iprot.readStructEnd()
16511 
 
16512 
  def write(self, oprot):
16513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16515 
      return
16516 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16517 
    if self.success is not None:
2536 chandransh 16518 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16519 
      oprot.writeBool(self.success)
16520 
      oprot.writeFieldEnd()
3431 rajveer 16521 
    if self.ex is not None:
2536 chandransh 16522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16523 
      self.ex.write(oprot)
16524 
      oprot.writeFieldEnd()
16525 
    oprot.writeFieldStop()
16526 
    oprot.writeStructEnd()
16527 
 
3431 rajveer 16528 
  def validate(self):
16529 
    return
16530 
 
16531 
 
2536 chandransh 16532 
  def __repr__(self):
16533 
    L = ['%s=%r' % (key, value)
16534 
      for key, value in self.__dict__.iteritems()]
16535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16536 
 
16537 
  def __eq__(self, other):
16538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16539 
 
16540 
  def __ne__(self, other):
16541 
    return not (self == other)
16542 
 
4712 rajveer 16543 
class markOrderAsDelivered_args:
16544 
  """
16545 
  Attributes:
16546 
   - orderId
16547 
   - deliveryTimestamp
16548 
   - receiver
16549 
  """
16550 
 
16551 
  thrift_spec = None
16552 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16553 
    self.orderId = orderId
16554 
    self.deliveryTimestamp = deliveryTimestamp
16555 
    self.receiver = receiver
16556 
 
16557 
  def read(self, iprot):
16558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16560 
      return
16561 
    iprot.readStructBegin()
16562 
    while True:
16563 
      (fname, ftype, fid) = iprot.readFieldBegin()
16564 
      if ftype == TType.STOP:
16565 
        break
16566 
      if fid == 1:
16567 
        if ftype == TType.I64:
16568 
          self.orderId = iprot.readI64();
16569 
        else:
16570 
          iprot.skip(ftype)
16571 
      elif fid == 2:
16572 
        if ftype == TType.I64:
16573 
          self.deliveryTimestamp = iprot.readI64();
16574 
        else:
16575 
          iprot.skip(ftype)
16576 
      elif fid == -1:
16577 
        if ftype == TType.STRING:
16578 
          self.receiver = iprot.readString();
16579 
        else:
16580 
          iprot.skip(ftype)
16581 
      else:
16582 
        iprot.skip(ftype)
16583 
      iprot.readFieldEnd()
16584 
    iprot.readStructEnd()
16585 
 
16586 
  def write(self, oprot):
16587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16589 
      return
16590 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16591 
    if self.receiver is not None:
16592 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16593 
      oprot.writeString(self.receiver)
16594 
      oprot.writeFieldEnd()
16595 
    if self.orderId is not None:
16596 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16597 
      oprot.writeI64(self.orderId)
16598 
      oprot.writeFieldEnd()
16599 
    if self.deliveryTimestamp is not None:
16600 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16601 
      oprot.writeI64(self.deliveryTimestamp)
16602 
      oprot.writeFieldEnd()
16603 
    oprot.writeFieldStop()
16604 
    oprot.writeStructEnd()
16605 
 
16606 
  def validate(self):
16607 
    return
16608 
 
16609 
 
16610 
  def __repr__(self):
16611 
    L = ['%s=%r' % (key, value)
16612 
      for key, value in self.__dict__.iteritems()]
16613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16614 
 
16615 
  def __eq__(self, other):
16616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16617 
 
16618 
  def __ne__(self, other):
16619 
    return not (self == other)
16620 
 
16621 
class markOrderAsDelivered_result:
16622 
  """
16623 
  Attributes:
16624 
   - ex
16625 
  """
16626 
 
16627 
  thrift_spec = (
16628 
    None, # 0
16629 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16630 
  )
16631 
 
16632 
  def __init__(self, ex=None,):
16633 
    self.ex = ex
16634 
 
16635 
  def read(self, iprot):
16636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16638 
      return
16639 
    iprot.readStructBegin()
16640 
    while True:
16641 
      (fname, ftype, fid) = iprot.readFieldBegin()
16642 
      if ftype == TType.STOP:
16643 
        break
16644 
      if fid == 1:
16645 
        if ftype == TType.STRUCT:
16646 
          self.ex = TransactionServiceException()
16647 
          self.ex.read(iprot)
16648 
        else:
16649 
          iprot.skip(ftype)
16650 
      else:
16651 
        iprot.skip(ftype)
16652 
      iprot.readFieldEnd()
16653 
    iprot.readStructEnd()
16654 
 
16655 
  def write(self, oprot):
16656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16658 
      return
16659 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16660 
    if self.ex is not None:
16661 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16662 
      self.ex.write(oprot)
16663 
      oprot.writeFieldEnd()
16664 
    oprot.writeFieldStop()
16665 
    oprot.writeStructEnd()
16666 
 
16667 
  def validate(self):
16668 
    return
16669 
 
16670 
 
16671 
  def __repr__(self):
16672 
    L = ['%s=%r' % (key, value)
16673 
      for key, value in self.__dict__.iteritems()]
16674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16675 
 
16676 
  def __eq__(self, other):
16677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16678 
 
16679 
  def __ne__(self, other):
16680 
    return not (self == other)
16681 
 
5553 rajveer 16682 
class markOrderAsReceivedAtStore_args:
16683 
  """
16684 
  Attributes:
16685 
   - orderId
16686 
   - deliveryTimestamp
16687 
  """
16688 
 
16689 
  thrift_spec = (
16690 
    None, # 0
16691 
    (1, TType.I64, 'orderId', None, None, ), # 1
16692 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16693 
  )
16694 
 
16695 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16696 
    self.orderId = orderId
16697 
    self.deliveryTimestamp = deliveryTimestamp
16698 
 
16699 
  def read(self, iprot):
16700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16702 
      return
16703 
    iprot.readStructBegin()
16704 
    while True:
16705 
      (fname, ftype, fid) = iprot.readFieldBegin()
16706 
      if ftype == TType.STOP:
16707 
        break
16708 
      if fid == 1:
16709 
        if ftype == TType.I64:
16710 
          self.orderId = iprot.readI64();
16711 
        else:
16712 
          iprot.skip(ftype)
16713 
      elif fid == 2:
16714 
        if ftype == TType.I64:
16715 
          self.deliveryTimestamp = iprot.readI64();
16716 
        else:
16717 
          iprot.skip(ftype)
16718 
      else:
16719 
        iprot.skip(ftype)
16720 
      iprot.readFieldEnd()
16721 
    iprot.readStructEnd()
16722 
 
16723 
  def write(self, oprot):
16724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16726 
      return
16727 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16728 
    if self.orderId is not None:
16729 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16730 
      oprot.writeI64(self.orderId)
16731 
      oprot.writeFieldEnd()
16732 
    if self.deliveryTimestamp is not None:
16733 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16734 
      oprot.writeI64(self.deliveryTimestamp)
16735 
      oprot.writeFieldEnd()
16736 
    oprot.writeFieldStop()
16737 
    oprot.writeStructEnd()
16738 
 
16739 
  def validate(self):
16740 
    return
16741 
 
16742 
 
16743 
  def __repr__(self):
16744 
    L = ['%s=%r' % (key, value)
16745 
      for key, value in self.__dict__.iteritems()]
16746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16747 
 
16748 
  def __eq__(self, other):
16749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16750 
 
16751 
  def __ne__(self, other):
16752 
    return not (self == other)
16753 
 
16754 
class markOrderAsReceivedAtStore_result:
16755 
  """
16756 
  Attributes:
16757 
   - ex
16758 
  """
16759 
 
16760 
  thrift_spec = (
16761 
    None, # 0
16762 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16763 
  )
16764 
 
16765 
  def __init__(self, ex=None,):
16766 
    self.ex = ex
16767 
 
16768 
  def read(self, iprot):
16769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16771 
      return
16772 
    iprot.readStructBegin()
16773 
    while True:
16774 
      (fname, ftype, fid) = iprot.readFieldBegin()
16775 
      if ftype == TType.STOP:
16776 
        break
16777 
      if fid == 1:
16778 
        if ftype == TType.STRUCT:
16779 
          self.ex = TransactionServiceException()
16780 
          self.ex.read(iprot)
16781 
        else:
16782 
          iprot.skip(ftype)
16783 
      else:
16784 
        iprot.skip(ftype)
16785 
      iprot.readFieldEnd()
16786 
    iprot.readStructEnd()
16787 
 
16788 
  def write(self, oprot):
16789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16791 
      return
16792 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16793 
    if self.ex is not None:
16794 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16795 
      self.ex.write(oprot)
16796 
      oprot.writeFieldEnd()
16797 
    oprot.writeFieldStop()
16798 
    oprot.writeStructEnd()
16799 
 
16800 
  def validate(self):
16801 
    return
16802 
 
16803 
 
16804 
  def __repr__(self):
16805 
    L = ['%s=%r' % (key, value)
16806 
      for key, value in self.__dict__.iteritems()]
16807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16808 
 
16809 
  def __eq__(self, other):
16810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16811 
 
16812 
  def __ne__(self, other):
16813 
    return not (self == other)
16814 
 
4454 rajveer 16815 
class markOrderDoaRequestReceived_args:
16816 
  """
16817 
  Attributes:
16818 
   - orderId
16819 
  """
16820 
 
16821 
  thrift_spec = (
16822 
    None, # 0
16823 
    (1, TType.I64, 'orderId', None, None, ), # 1
16824 
  )
16825 
 
16826 
  def __init__(self, orderId=None,):
16827 
    self.orderId = orderId
16828 
 
16829 
  def read(self, iprot):
16830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16832 
      return
16833 
    iprot.readStructBegin()
16834 
    while True:
16835 
      (fname, ftype, fid) = iprot.readFieldBegin()
16836 
      if ftype == TType.STOP:
16837 
        break
16838 
      if fid == 1:
16839 
        if ftype == TType.I64:
16840 
          self.orderId = iprot.readI64();
16841 
        else:
16842 
          iprot.skip(ftype)
16843 
      else:
16844 
        iprot.skip(ftype)
16845 
      iprot.readFieldEnd()
16846 
    iprot.readStructEnd()
16847 
 
16848 
  def write(self, oprot):
16849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16851 
      return
16852 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16853 
    if self.orderId is not None:
16854 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16855 
      oprot.writeI64(self.orderId)
16856 
      oprot.writeFieldEnd()
16857 
    oprot.writeFieldStop()
16858 
    oprot.writeStructEnd()
16859 
 
16860 
  def validate(self):
16861 
    return
16862 
 
16863 
 
16864 
  def __repr__(self):
16865 
    L = ['%s=%r' % (key, value)
16866 
      for key, value in self.__dict__.iteritems()]
16867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16868 
 
16869 
  def __eq__(self, other):
16870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16871 
 
16872 
  def __ne__(self, other):
16873 
    return not (self == other)
16874 
 
16875 
class markOrderDoaRequestReceived_result:
16876 
  """
16877 
  Attributes:
16878 
   - success
16879 
   - ex
16880 
  """
16881 
 
16882 
  thrift_spec = (
16883 
    (0, TType.BOOL, 'success', None, None, ), # 0
16884 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16885 
  )
16886 
 
16887 
  def __init__(self, success=None, ex=None,):
16888 
    self.success = success
16889 
    self.ex = ex
16890 
 
16891 
  def read(self, iprot):
16892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16894 
      return
16895 
    iprot.readStructBegin()
16896 
    while True:
16897 
      (fname, ftype, fid) = iprot.readFieldBegin()
16898 
      if ftype == TType.STOP:
16899 
        break
16900 
      if fid == 0:
16901 
        if ftype == TType.BOOL:
16902 
          self.success = iprot.readBool();
16903 
        else:
16904 
          iprot.skip(ftype)
16905 
      elif fid == 1:
16906 
        if ftype == TType.STRUCT:
16907 
          self.ex = TransactionServiceException()
16908 
          self.ex.read(iprot)
16909 
        else:
16910 
          iprot.skip(ftype)
16911 
      else:
16912 
        iprot.skip(ftype)
16913 
      iprot.readFieldEnd()
16914 
    iprot.readStructEnd()
16915 
 
16916 
  def write(self, oprot):
16917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16919 
      return
16920 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16921 
    if self.success is not None:
16922 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16923 
      oprot.writeBool(self.success)
16924 
      oprot.writeFieldEnd()
16925 
    if self.ex is not None:
16926 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16927 
      self.ex.write(oprot)
16928 
      oprot.writeFieldEnd()
16929 
    oprot.writeFieldStop()
16930 
    oprot.writeStructEnd()
16931 
 
16932 
  def validate(self):
16933 
    return
16934 
 
16935 
 
16936 
  def __repr__(self):
16937 
    L = ['%s=%r' % (key, value)
16938 
      for key, value in self.__dict__.iteritems()]
16939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16940 
 
16941 
  def __eq__(self, other):
16942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16943 
 
16944 
  def __ne__(self, other):
16945 
    return not (self == other)
16946 
 
16947 
class markOrderDoaRequestAuthorized_args:
16948 
  """
16949 
  Attributes:
16950 
   - orderId
16951 
   - isAuthorized
16952 
  """
16953 
 
16954 
  thrift_spec = (
16955 
    None, # 0
16956 
    (1, TType.I64, 'orderId', None, None, ), # 1
16957 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16958 
  )
16959 
 
16960 
  def __init__(self, orderId=None, isAuthorized=None,):
16961 
    self.orderId = orderId
16962 
    self.isAuthorized = isAuthorized
16963 
 
16964 
  def read(self, iprot):
16965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16967 
      return
16968 
    iprot.readStructBegin()
16969 
    while True:
16970 
      (fname, ftype, fid) = iprot.readFieldBegin()
16971 
      if ftype == TType.STOP:
16972 
        break
16973 
      if fid == 1:
16974 
        if ftype == TType.I64:
16975 
          self.orderId = iprot.readI64();
16976 
        else:
16977 
          iprot.skip(ftype)
16978 
      elif fid == 2:
16979 
        if ftype == TType.BOOL:
16980 
          self.isAuthorized = iprot.readBool();
16981 
        else:
16982 
          iprot.skip(ftype)
16983 
      else:
16984 
        iprot.skip(ftype)
16985 
      iprot.readFieldEnd()
16986 
    iprot.readStructEnd()
16987 
 
16988 
  def write(self, oprot):
16989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16991 
      return
16992 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16993 
    if self.orderId is not None:
16994 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16995 
      oprot.writeI64(self.orderId)
16996 
      oprot.writeFieldEnd()
16997 
    if self.isAuthorized is not None:
16998 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16999 
      oprot.writeBool(self.isAuthorized)
17000 
      oprot.writeFieldEnd()
17001 
    oprot.writeFieldStop()
17002 
    oprot.writeStructEnd()
17003 
 
17004 
  def validate(self):
17005 
    return
17006 
 
17007 
 
17008 
  def __repr__(self):
17009 
    L = ['%s=%r' % (key, value)
17010 
      for key, value in self.__dict__.iteritems()]
17011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17012 
 
17013 
  def __eq__(self, other):
17014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17015 
 
17016 
  def __ne__(self, other):
17017 
    return not (self == other)
17018 
 
17019 
class markOrderDoaRequestAuthorized_result:
17020 
  """
17021 
  Attributes:
17022 
   - success
17023 
   - ex
17024 
  """
17025 
 
17026 
  thrift_spec = (
17027 
    (0, TType.BOOL, 'success', None, None, ), # 0
17028 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17029 
  )
17030 
 
17031 
  def __init__(self, success=None, ex=None,):
17032 
    self.success = success
17033 
    self.ex = ex
17034 
 
17035 
  def read(self, iprot):
17036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17038 
      return
17039 
    iprot.readStructBegin()
17040 
    while True:
17041 
      (fname, ftype, fid) = iprot.readFieldBegin()
17042 
      if ftype == TType.STOP:
17043 
        break
17044 
      if fid == 0:
17045 
        if ftype == TType.BOOL:
17046 
          self.success = iprot.readBool();
17047 
        else:
17048 
          iprot.skip(ftype)
17049 
      elif fid == 1:
17050 
        if ftype == TType.STRUCT:
17051 
          self.ex = TransactionServiceException()
17052 
          self.ex.read(iprot)
17053 
        else:
17054 
          iprot.skip(ftype)
17055 
      else:
17056 
        iprot.skip(ftype)
17057 
      iprot.readFieldEnd()
17058 
    iprot.readStructEnd()
17059 
 
17060 
  def write(self, oprot):
17061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17063 
      return
17064 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17065 
    if self.success is not None:
17066 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17067 
      oprot.writeBool(self.success)
17068 
      oprot.writeFieldEnd()
17069 
    if self.ex is not None:
17070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17071 
      self.ex.write(oprot)
17072 
      oprot.writeFieldEnd()
17073 
    oprot.writeFieldStop()
17074 
    oprot.writeStructEnd()
17075 
 
17076 
  def validate(self):
17077 
    return
17078 
 
17079 
 
17080 
  def __repr__(self):
17081 
    L = ['%s=%r' % (key, value)
17082 
      for key, value in self.__dict__.iteritems()]
17083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17084 
 
17085 
  def __eq__(self, other):
17086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17087 
 
17088 
  def __ne__(self, other):
17089 
    return not (self == other)
17090 
 
4488 rajveer 17091 
class markOrderReturnRequestReceived_args:
17092 
  """
17093 
  Attributes:
17094 
   - orderId
17095 
  """
17096 
 
17097 
  thrift_spec = (
17098 
    None, # 0
17099 
    (1, TType.I64, 'orderId', None, None, ), # 1
17100 
  )
17101 
 
17102 
  def __init__(self, orderId=None,):
17103 
    self.orderId = orderId
17104 
 
17105 
  def read(self, iprot):
17106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17108 
      return
17109 
    iprot.readStructBegin()
17110 
    while True:
17111 
      (fname, ftype, fid) = iprot.readFieldBegin()
17112 
      if ftype == TType.STOP:
17113 
        break
17114 
      if fid == 1:
17115 
        if ftype == TType.I64:
17116 
          self.orderId = iprot.readI64();
17117 
        else:
17118 
          iprot.skip(ftype)
17119 
      else:
17120 
        iprot.skip(ftype)
17121 
      iprot.readFieldEnd()
17122 
    iprot.readStructEnd()
17123 
 
17124 
  def write(self, oprot):
17125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17127 
      return
17128 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17129 
    if self.orderId is not None:
17130 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17131 
      oprot.writeI64(self.orderId)
17132 
      oprot.writeFieldEnd()
17133 
    oprot.writeFieldStop()
17134 
    oprot.writeStructEnd()
17135 
 
17136 
  def validate(self):
17137 
    return
17138 
 
17139 
 
17140 
  def __repr__(self):
17141 
    L = ['%s=%r' % (key, value)
17142 
      for key, value in self.__dict__.iteritems()]
17143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17144 
 
17145 
  def __eq__(self, other):
17146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17147 
 
17148 
  def __ne__(self, other):
17149 
    return not (self == other)
17150 
 
17151 
class markOrderReturnRequestReceived_result:
17152 
  """
17153 
  Attributes:
17154 
   - success
17155 
   - ex
17156 
  """
17157 
 
17158 
  thrift_spec = (
17159 
    (0, TType.BOOL, 'success', None, None, ), # 0
17160 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17161 
  )
17162 
 
17163 
  def __init__(self, success=None, ex=None,):
17164 
    self.success = success
17165 
    self.ex = ex
17166 
 
17167 
  def read(self, iprot):
17168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17170 
      return
17171 
    iprot.readStructBegin()
17172 
    while True:
17173 
      (fname, ftype, fid) = iprot.readFieldBegin()
17174 
      if ftype == TType.STOP:
17175 
        break
17176 
      if fid == 0:
17177 
        if ftype == TType.BOOL:
17178 
          self.success = iprot.readBool();
17179 
        else:
17180 
          iprot.skip(ftype)
17181 
      elif fid == 1:
17182 
        if ftype == TType.STRUCT:
17183 
          self.ex = TransactionServiceException()
17184 
          self.ex.read(iprot)
17185 
        else:
17186 
          iprot.skip(ftype)
17187 
      else:
17188 
        iprot.skip(ftype)
17189 
      iprot.readFieldEnd()
17190 
    iprot.readStructEnd()
17191 
 
17192 
  def write(self, oprot):
17193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17195 
      return
17196 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17197 
    if self.success is not None:
17198 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17199 
      oprot.writeBool(self.success)
17200 
      oprot.writeFieldEnd()
17201 
    if self.ex is not None:
17202 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17203 
      self.ex.write(oprot)
17204 
      oprot.writeFieldEnd()
17205 
    oprot.writeFieldStop()
17206 
    oprot.writeStructEnd()
17207 
 
17208 
  def validate(self):
17209 
    return
17210 
 
17211 
 
17212 
  def __repr__(self):
17213 
    L = ['%s=%r' % (key, value)
17214 
      for key, value in self.__dict__.iteritems()]
17215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17216 
 
17217 
  def __eq__(self, other):
17218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17219 
 
17220 
  def __ne__(self, other):
17221 
    return not (self == other)
17222 
 
17223 
class markOrderReturnRequestAuthorized_args:
17224 
  """
17225 
  Attributes:
17226 
   - orderId
17227 
   - isAuthorized
17228 
  """
17229 
 
17230 
  thrift_spec = (
17231 
    None, # 0
17232 
    (1, TType.I64, 'orderId', None, None, ), # 1
17233 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17234 
  )
17235 
 
17236 
  def __init__(self, orderId=None, isAuthorized=None,):
17237 
    self.orderId = orderId
17238 
    self.isAuthorized = isAuthorized
17239 
 
17240 
  def read(self, iprot):
17241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17243 
      return
17244 
    iprot.readStructBegin()
17245 
    while True:
17246 
      (fname, ftype, fid) = iprot.readFieldBegin()
17247 
      if ftype == TType.STOP:
17248 
        break
17249 
      if fid == 1:
17250 
        if ftype == TType.I64:
17251 
          self.orderId = iprot.readI64();
17252 
        else:
17253 
          iprot.skip(ftype)
17254 
      elif fid == 2:
17255 
        if ftype == TType.BOOL:
17256 
          self.isAuthorized = iprot.readBool();
17257 
        else:
17258 
          iprot.skip(ftype)
17259 
      else:
17260 
        iprot.skip(ftype)
17261 
      iprot.readFieldEnd()
17262 
    iprot.readStructEnd()
17263 
 
17264 
  def write(self, oprot):
17265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17267 
      return
17268 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17269 
    if self.orderId is not None:
17270 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17271 
      oprot.writeI64(self.orderId)
17272 
      oprot.writeFieldEnd()
17273 
    if self.isAuthorized is not None:
17274 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17275 
      oprot.writeBool(self.isAuthorized)
17276 
      oprot.writeFieldEnd()
17277 
    oprot.writeFieldStop()
17278 
    oprot.writeStructEnd()
17279 
 
17280 
  def validate(self):
17281 
    return
17282 
 
17283 
 
17284 
  def __repr__(self):
17285 
    L = ['%s=%r' % (key, value)
17286 
      for key, value in self.__dict__.iteritems()]
17287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17288 
 
17289 
  def __eq__(self, other):
17290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17291 
 
17292 
  def __ne__(self, other):
17293 
    return not (self == other)
17294 
 
17295 
class markOrderReturnRequestAuthorized_result:
17296 
  """
17297 
  Attributes:
17298 
   - success
17299 
   - ex
17300 
  """
17301 
 
17302 
  thrift_spec = (
17303 
    (0, TType.BOOL, 'success', None, None, ), # 0
17304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17305 
  )
17306 
 
17307 
  def __init__(self, success=None, ex=None,):
17308 
    self.success = success
17309 
    self.ex = ex
17310 
 
17311 
  def read(self, iprot):
17312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17314 
      return
17315 
    iprot.readStructBegin()
17316 
    while True:
17317 
      (fname, ftype, fid) = iprot.readFieldBegin()
17318 
      if ftype == TType.STOP:
17319 
        break
17320 
      if fid == 0:
17321 
        if ftype == TType.BOOL:
17322 
          self.success = iprot.readBool();
17323 
        else:
17324 
          iprot.skip(ftype)
17325 
      elif fid == 1:
17326 
        if ftype == TType.STRUCT:
17327 
          self.ex = TransactionServiceException()
17328 
          self.ex.read(iprot)
17329 
        else:
17330 
          iprot.skip(ftype)
17331 
      else:
17332 
        iprot.skip(ftype)
17333 
      iprot.readFieldEnd()
17334 
    iprot.readStructEnd()
17335 
 
17336 
  def write(self, oprot):
17337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17339 
      return
17340 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17341 
    if self.success is not None:
17342 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17343 
      oprot.writeBool(self.success)
17344 
      oprot.writeFieldEnd()
17345 
    if self.ex is not None:
17346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17347 
      self.ex.write(oprot)
17348 
      oprot.writeFieldEnd()
17349 
    oprot.writeFieldStop()
17350 
    oprot.writeStructEnd()
17351 
 
17352 
  def validate(self):
17353 
    return
17354 
 
17355 
 
17356 
  def __repr__(self):
17357 
    L = ['%s=%r' % (key, value)
17358 
      for key, value in self.__dict__.iteritems()]
17359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17360 
 
17361 
  def __eq__(self, other):
17362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17363 
 
17364 
  def __ne__(self, other):
17365 
    return not (self == other)
17366 
 
2536 chandransh 17367 
class requestPickupNumber_args:
17368 
  """
17369 
  Attributes:
17370 
   - orderId
4579 rajveer 17371 
   - providerId
2536 chandransh 17372 
  """
17373 
 
17374 
  thrift_spec = (
17375 
    None, # 0
17376 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17377 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17378 
  )
17379 
 
4579 rajveer 17380 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17381 
    self.orderId = orderId
4579 rajveer 17382 
    self.providerId = providerId
2536 chandransh 17383 
 
17384 
  def read(self, iprot):
17385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17387 
      return
17388 
    iprot.readStructBegin()
17389 
    while True:
17390 
      (fname, ftype, fid) = iprot.readFieldBegin()
17391 
      if ftype == TType.STOP:
17392 
        break
17393 
      if fid == 1:
17394 
        if ftype == TType.I64:
17395 
          self.orderId = iprot.readI64();
17396 
        else:
17397 
          iprot.skip(ftype)
4579 rajveer 17398 
      elif fid == 2:
17399 
        if ftype == TType.I64:
17400 
          self.providerId = iprot.readI64();
17401 
        else:
17402 
          iprot.skip(ftype)
2536 chandransh 17403 
      else:
17404 
        iprot.skip(ftype)
17405 
      iprot.readFieldEnd()
17406 
    iprot.readStructEnd()
17407 
 
17408 
  def write(self, oprot):
17409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17411 
      return
17412 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17413 
    if self.orderId is not None:
2536 chandransh 17414 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17415 
      oprot.writeI64(self.orderId)
17416 
      oprot.writeFieldEnd()
4579 rajveer 17417 
    if self.providerId is not None:
17418 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17419 
      oprot.writeI64(self.providerId)
17420 
      oprot.writeFieldEnd()
2536 chandransh 17421 
    oprot.writeFieldStop()
17422 
    oprot.writeStructEnd()
17423 
 
3431 rajveer 17424 
  def validate(self):
17425 
    return
17426 
 
17427 
 
2536 chandransh 17428 
  def __repr__(self):
17429 
    L = ['%s=%r' % (key, value)
17430 
      for key, value in self.__dict__.iteritems()]
17431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17432 
 
17433 
  def __eq__(self, other):
17434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17435 
 
17436 
  def __ne__(self, other):
17437 
    return not (self == other)
17438 
 
17439 
class requestPickupNumber_result:
17440 
  """
17441 
  Attributes:
17442 
   - success
17443 
   - ex
17444 
  """
17445 
 
17446 
  thrift_spec = (
17447 
    (0, TType.BOOL, 'success', None, None, ), # 0
17448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17449 
  )
17450 
 
17451 
  def __init__(self, success=None, ex=None,):
17452 
    self.success = success
17453 
    self.ex = ex
17454 
 
17455 
  def read(self, iprot):
17456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17458 
      return
17459 
    iprot.readStructBegin()
17460 
    while True:
17461 
      (fname, ftype, fid) = iprot.readFieldBegin()
17462 
      if ftype == TType.STOP:
17463 
        break
17464 
      if fid == 0:
17465 
        if ftype == TType.BOOL:
17466 
          self.success = iprot.readBool();
17467 
        else:
17468 
          iprot.skip(ftype)
17469 
      elif fid == 1:
17470 
        if ftype == TType.STRUCT:
17471 
          self.ex = TransactionServiceException()
17472 
          self.ex.read(iprot)
17473 
        else:
17474 
          iprot.skip(ftype)
17475 
      else:
17476 
        iprot.skip(ftype)
17477 
      iprot.readFieldEnd()
17478 
    iprot.readStructEnd()
17479 
 
17480 
  def write(self, oprot):
17481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17483 
      return
17484 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17485 
    if self.success is not None:
2536 chandransh 17486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17487 
      oprot.writeBool(self.success)
17488 
      oprot.writeFieldEnd()
3431 rajveer 17489 
    if self.ex is not None:
2536 chandransh 17490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17491 
      self.ex.write(oprot)
17492 
      oprot.writeFieldEnd()
17493 
    oprot.writeFieldStop()
17494 
    oprot.writeStructEnd()
17495 
 
3431 rajveer 17496 
  def validate(self):
17497 
    return
17498 
 
17499 
 
2536 chandransh 17500 
  def __repr__(self):
17501 
    L = ['%s=%r' % (key, value)
17502 
      for key, value in self.__dict__.iteritems()]
17503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17504 
 
17505 
  def __eq__(self, other):
17506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17507 
 
17508 
  def __ne__(self, other):
17509 
    return not (self == other)
17510 
 
17511 
class authorizePickup_args:
17512 
  """
17513 
  Attributes:
17514 
   - orderId
17515 
   - pickupNumber
4602 rajveer 17516 
   - providerId
2536 chandransh 17517 
  """
17518 
 
17519 
  thrift_spec = (
17520 
    None, # 0
17521 
    (1, TType.I64, 'orderId', None, None, ), # 1
17522 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17523 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17524 
  )
17525 
 
4602 rajveer 17526 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17527 
    self.orderId = orderId
17528 
    self.pickupNumber = pickupNumber
4602 rajveer 17529 
    self.providerId = providerId
2536 chandransh 17530 
 
17531 
  def read(self, iprot):
17532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17534 
      return
17535 
    iprot.readStructBegin()
17536 
    while True:
17537 
      (fname, ftype, fid) = iprot.readFieldBegin()
17538 
      if ftype == TType.STOP:
17539 
        break
17540 
      if fid == 1:
17541 
        if ftype == TType.I64:
17542 
          self.orderId = iprot.readI64();
17543 
        else:
17544 
          iprot.skip(ftype)
17545 
      elif fid == 2:
17546 
        if ftype == TType.STRING:
17547 
          self.pickupNumber = iprot.readString();
17548 
        else:
17549 
          iprot.skip(ftype)
4602 rajveer 17550 
      elif fid == 3:
17551 
        if ftype == TType.I64:
17552 
          self.providerId = iprot.readI64();
17553 
        else:
17554 
          iprot.skip(ftype)
2536 chandransh 17555 
      else:
17556 
        iprot.skip(ftype)
17557 
      iprot.readFieldEnd()
17558 
    iprot.readStructEnd()
17559 
 
17560 
  def write(self, oprot):
17561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17563 
      return
17564 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17565 
    if self.orderId is not None:
2536 chandransh 17566 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17567 
      oprot.writeI64(self.orderId)
17568 
      oprot.writeFieldEnd()
3431 rajveer 17569 
    if self.pickupNumber is not None:
2536 chandransh 17570 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17571 
      oprot.writeString(self.pickupNumber)
17572 
      oprot.writeFieldEnd()
4602 rajveer 17573 
    if self.providerId is not None:
17574 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17575 
      oprot.writeI64(self.providerId)
17576 
      oprot.writeFieldEnd()
2536 chandransh 17577 
    oprot.writeFieldStop()
17578 
    oprot.writeStructEnd()
17579 
 
3431 rajveer 17580 
  def validate(self):
17581 
    return
17582 
 
17583 
 
2536 chandransh 17584 
  def __repr__(self):
17585 
    L = ['%s=%r' % (key, value)
17586 
      for key, value in self.__dict__.iteritems()]
17587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17588 
 
17589 
  def __eq__(self, other):
17590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17591 
 
17592 
  def __ne__(self, other):
17593 
    return not (self == other)
17594 
 
17595 
class authorizePickup_result:
17596 
  """
17597 
  Attributes:
17598 
   - success
17599 
   - ex
17600 
  """
17601 
 
17602 
  thrift_spec = (
17603 
    (0, TType.BOOL, 'success', None, None, ), # 0
17604 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17605 
  )
17606 
 
17607 
  def __init__(self, success=None, ex=None,):
17608 
    self.success = success
17609 
    self.ex = ex
17610 
 
17611 
  def read(self, iprot):
17612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17614 
      return
17615 
    iprot.readStructBegin()
17616 
    while True:
17617 
      (fname, ftype, fid) = iprot.readFieldBegin()
17618 
      if ftype == TType.STOP:
17619 
        break
17620 
      if fid == 0:
17621 
        if ftype == TType.BOOL:
17622 
          self.success = iprot.readBool();
17623 
        else:
17624 
          iprot.skip(ftype)
17625 
      elif fid == 1:
17626 
        if ftype == TType.STRUCT:
17627 
          self.ex = TransactionServiceException()
17628 
          self.ex.read(iprot)
17629 
        else:
17630 
          iprot.skip(ftype)
17631 
      else:
17632 
        iprot.skip(ftype)
17633 
      iprot.readFieldEnd()
17634 
    iprot.readStructEnd()
17635 
 
17636 
  def write(self, oprot):
17637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17639 
      return
17640 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17641 
    if self.success is not None:
2536 chandransh 17642 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17643 
      oprot.writeBool(self.success)
17644 
      oprot.writeFieldEnd()
3431 rajveer 17645 
    if self.ex is not None:
2536 chandransh 17646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17647 
      self.ex.write(oprot)
17648 
      oprot.writeFieldEnd()
17649 
    oprot.writeFieldStop()
17650 
    oprot.writeStructEnd()
17651 
 
3431 rajveer 17652 
  def validate(self):
17653 
    return
17654 
 
17655 
 
2536 chandransh 17656 
  def __repr__(self):
17657 
    L = ['%s=%r' % (key, value)
17658 
      for key, value in self.__dict__.iteritems()]
17659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17660 
 
17661 
  def __eq__(self, other):
17662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17663 
 
17664 
  def __ne__(self, other):
17665 
    return not (self == other)
17666 
 
2764 chandransh 17667 
class markDoasAsPickedUp_args:
17668 
  """
17669 
  Attributes:
17670 
   - providerId
17671 
   - pickupDetails
17672 
  """
17673 
 
17674 
  thrift_spec = (
17675 
    None, # 0
17676 
    (1, TType.I64, 'providerId', None, None, ), # 1
17677 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17678 
  )
17679 
 
17680 
  def __init__(self, providerId=None, pickupDetails=None,):
17681 
    self.providerId = providerId
17682 
    self.pickupDetails = pickupDetails
17683 
 
17684 
  def read(self, iprot):
17685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17687 
      return
17688 
    iprot.readStructBegin()
17689 
    while True:
17690 
      (fname, ftype, fid) = iprot.readFieldBegin()
17691 
      if ftype == TType.STOP:
17692 
        break
17693 
      if fid == 1:
17694 
        if ftype == TType.I64:
17695 
          self.providerId = iprot.readI64();
17696 
        else:
17697 
          iprot.skip(ftype)
17698 
      elif fid == 2:
17699 
        if ftype == TType.MAP:
17700 
          self.pickupDetails = {}
6188 rajveer 17701 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17702 
          for _i411 in xrange(_size407):
17703 
            _key412 = iprot.readString();
17704 
            _val413 = iprot.readString();
17705 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17706 
          iprot.readMapEnd()
17707 
        else:
17708 
          iprot.skip(ftype)
17709 
      else:
17710 
        iprot.skip(ftype)
17711 
      iprot.readFieldEnd()
17712 
    iprot.readStructEnd()
17713 
 
17714 
  def write(self, oprot):
17715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17717 
      return
17718 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17719 
    if self.providerId is not None:
2764 chandransh 17720 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17721 
      oprot.writeI64(self.providerId)
17722 
      oprot.writeFieldEnd()
3431 rajveer 17723 
    if self.pickupDetails is not None:
2764 chandransh 17724 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17725 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17726 
      for kiter414,viter415 in self.pickupDetails.items():
17727 
        oprot.writeString(kiter414)
17728 
        oprot.writeString(viter415)
2764 chandransh 17729 
      oprot.writeMapEnd()
17730 
      oprot.writeFieldEnd()
17731 
    oprot.writeFieldStop()
17732 
    oprot.writeStructEnd()
17733 
 
3431 rajveer 17734 
  def validate(self):
17735 
    return
17736 
 
17737 
 
2764 chandransh 17738 
  def __repr__(self):
17739 
    L = ['%s=%r' % (key, value)
17740 
      for key, value in self.__dict__.iteritems()]
17741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17742 
 
17743 
  def __eq__(self, other):
17744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17745 
 
17746 
  def __ne__(self, other):
17747 
    return not (self == other)
17748 
 
17749 
class markDoasAsPickedUp_result:
4910 phani.kuma 17750 
 
17751 
  thrift_spec = (
17752 
  )
17753 
 
17754 
  def read(self, iprot):
17755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17757 
      return
17758 
    iprot.readStructBegin()
17759 
    while True:
17760 
      (fname, ftype, fid) = iprot.readFieldBegin()
17761 
      if ftype == TType.STOP:
17762 
        break
17763 
      else:
17764 
        iprot.skip(ftype)
17765 
      iprot.readFieldEnd()
17766 
    iprot.readStructEnd()
17767 
 
17768 
  def write(self, oprot):
17769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17771 
      return
17772 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17773 
    oprot.writeFieldStop()
17774 
    oprot.writeStructEnd()
17775 
 
17776 
  def validate(self):
17777 
    return
17778 
 
17779 
 
17780 
  def __repr__(self):
17781 
    L = ['%s=%r' % (key, value)
17782 
      for key, value in self.__dict__.iteritems()]
17783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17784 
 
17785 
  def __eq__(self, other):
17786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17787 
 
17788 
  def __ne__(self, other):
17789 
    return not (self == other)
17790 
 
17791 
class getDoasNotPickedUp_args:
2764 chandransh 17792 
  """
17793 
  Attributes:
4910 phani.kuma 17794 
   - providerId
17795 
  """
17796 
 
17797 
  thrift_spec = (
17798 
    None, # 0
17799 
    (1, TType.I64, 'providerId', None, None, ), # 1
17800 
  )
17801 
 
17802 
  def __init__(self, providerId=None,):
17803 
    self.providerId = providerId
17804 
 
17805 
  def read(self, iprot):
17806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17808 
      return
17809 
    iprot.readStructBegin()
17810 
    while True:
17811 
      (fname, ftype, fid) = iprot.readFieldBegin()
17812 
      if ftype == TType.STOP:
17813 
        break
17814 
      if fid == 1:
17815 
        if ftype == TType.I64:
17816 
          self.providerId = iprot.readI64();
17817 
        else:
17818 
          iprot.skip(ftype)
17819 
      else:
17820 
        iprot.skip(ftype)
17821 
      iprot.readFieldEnd()
17822 
    iprot.readStructEnd()
17823 
 
17824 
  def write(self, oprot):
17825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17827 
      return
17828 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17829 
    if self.providerId is not None:
17830 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17831 
      oprot.writeI64(self.providerId)
17832 
      oprot.writeFieldEnd()
17833 
    oprot.writeFieldStop()
17834 
    oprot.writeStructEnd()
17835 
 
17836 
  def validate(self):
17837 
    return
17838 
 
17839 
 
17840 
  def __repr__(self):
17841 
    L = ['%s=%r' % (key, value)
17842 
      for key, value in self.__dict__.iteritems()]
17843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17844 
 
17845 
  def __eq__(self, other):
17846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17847 
 
17848 
  def __ne__(self, other):
17849 
    return not (self == other)
17850 
 
17851 
class getDoasNotPickedUp_result:
17852 
  """
17853 
  Attributes:
2764 chandransh 17854 
   - success
17855 
  """
17856 
 
17857 
  thrift_spec = (
17858 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17859 
  )
17860 
 
17861 
  def __init__(self, success=None,):
17862 
    self.success = success
17863 
 
17864 
  def read(self, iprot):
17865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17867 
      return
17868 
    iprot.readStructBegin()
17869 
    while True:
17870 
      (fname, ftype, fid) = iprot.readFieldBegin()
17871 
      if ftype == TType.STOP:
17872 
        break
17873 
      if fid == 0:
17874 
        if ftype == TType.LIST:
17875 
          self.success = []
6188 rajveer 17876 
          (_etype419, _size416) = iprot.readListBegin()
17877 
          for _i420 in xrange(_size416):
17878 
            _elem421 = Order()
17879 
            _elem421.read(iprot)
17880 
            self.success.append(_elem421)
2764 chandransh 17881 
          iprot.readListEnd()
17882 
        else:
17883 
          iprot.skip(ftype)
17884 
      else:
17885 
        iprot.skip(ftype)
17886 
      iprot.readFieldEnd()
17887 
    iprot.readStructEnd()
17888 
 
17889 
  def write(self, oprot):
17890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17892 
      return
4910 phani.kuma 17893 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17894 
    if self.success is not None:
2764 chandransh 17895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17896 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17897 
      for iter422 in self.success:
17898 
        iter422.write(oprot)
2764 chandransh 17899 
      oprot.writeListEnd()
17900 
      oprot.writeFieldEnd()
17901 
    oprot.writeFieldStop()
17902 
    oprot.writeStructEnd()
17903 
 
3431 rajveer 17904 
  def validate(self):
17905 
    return
17906 
 
17907 
 
2764 chandransh 17908 
  def __repr__(self):
17909 
    L = ['%s=%r' % (key, value)
17910 
      for key, value in self.__dict__.iteritems()]
17911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17912 
 
17913 
  def __eq__(self, other):
17914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17915 
 
17916 
  def __ne__(self, other):
17917 
    return not (self == other)
17918 
 
4741 phani.kuma 17919 
class markReturnOrdersAsPickedUp_args:
17920 
  """
17921 
  Attributes:
17922 
   - providerId
17923 
   - pickupDetails
17924 
  """
17925 
 
17926 
  thrift_spec = (
17927 
    None, # 0
17928 
    (1, TType.I64, 'providerId', None, None, ), # 1
17929 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17930 
  )
17931 
 
17932 
  def __init__(self, providerId=None, pickupDetails=None,):
17933 
    self.providerId = providerId
17934 
    self.pickupDetails = pickupDetails
17935 
 
17936 
  def read(self, iprot):
17937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17939 
      return
17940 
    iprot.readStructBegin()
17941 
    while True:
17942 
      (fname, ftype, fid) = iprot.readFieldBegin()
17943 
      if ftype == TType.STOP:
17944 
        break
17945 
      if fid == 1:
17946 
        if ftype == TType.I64:
17947 
          self.providerId = iprot.readI64();
17948 
        else:
17949 
          iprot.skip(ftype)
17950 
      elif fid == 2:
17951 
        if ftype == TType.MAP:
17952 
          self.pickupDetails = {}
6188 rajveer 17953 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17954 
          for _i427 in xrange(_size423):
17955 
            _key428 = iprot.readString();
17956 
            _val429 = iprot.readString();
17957 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17958 
          iprot.readMapEnd()
17959 
        else:
17960 
          iprot.skip(ftype)
17961 
      else:
17962 
        iprot.skip(ftype)
17963 
      iprot.readFieldEnd()
17964 
    iprot.readStructEnd()
17965 
 
17966 
  def write(self, oprot):
17967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17969 
      return
17970 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17971 
    if self.providerId is not None:
17972 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17973 
      oprot.writeI64(self.providerId)
17974 
      oprot.writeFieldEnd()
17975 
    if self.pickupDetails is not None:
17976 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17977 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17978 
      for kiter430,viter431 in self.pickupDetails.items():
17979 
        oprot.writeString(kiter430)
17980 
        oprot.writeString(viter431)
4741 phani.kuma 17981 
      oprot.writeMapEnd()
17982 
      oprot.writeFieldEnd()
17983 
    oprot.writeFieldStop()
17984 
    oprot.writeStructEnd()
17985 
 
17986 
  def validate(self):
17987 
    return
17988 
 
17989 
 
17990 
  def __repr__(self):
17991 
    L = ['%s=%r' % (key, value)
17992 
      for key, value in self.__dict__.iteritems()]
17993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17994 
 
17995 
  def __eq__(self, other):
17996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17997 
 
17998 
  def __ne__(self, other):
17999 
    return not (self == other)
18000 
 
18001 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18002 
 
18003 
  thrift_spec = (
18004 
  )
18005 
 
18006 
  def read(self, iprot):
18007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18009 
      return
18010 
    iprot.readStructBegin()
18011 
    while True:
18012 
      (fname, ftype, fid) = iprot.readFieldBegin()
18013 
      if ftype == TType.STOP:
18014 
        break
18015 
      else:
18016 
        iprot.skip(ftype)
18017 
      iprot.readFieldEnd()
18018 
    iprot.readStructEnd()
18019 
 
18020 
  def write(self, oprot):
18021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18023 
      return
18024 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18025 
    oprot.writeFieldStop()
18026 
    oprot.writeStructEnd()
18027 
 
18028 
  def validate(self):
18029 
    return
18030 
 
18031 
 
18032 
  def __repr__(self):
18033 
    L = ['%s=%r' % (key, value)
18034 
      for key, value in self.__dict__.iteritems()]
18035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18036 
 
18037 
  def __eq__(self, other):
18038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18039 
 
18040 
  def __ne__(self, other):
18041 
    return not (self == other)
18042 
 
18043 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18044 
  """
18045 
  Attributes:
4910 phani.kuma 18046 
   - providerId
18047 
  """
18048 
 
18049 
  thrift_spec = (
18050 
    None, # 0
18051 
    (1, TType.I64, 'providerId', None, None, ), # 1
18052 
  )
18053 
 
18054 
  def __init__(self, providerId=None,):
18055 
    self.providerId = providerId
18056 
 
18057 
  def read(self, iprot):
18058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18060 
      return
18061 
    iprot.readStructBegin()
18062 
    while True:
18063 
      (fname, ftype, fid) = iprot.readFieldBegin()
18064 
      if ftype == TType.STOP:
18065 
        break
18066 
      if fid == 1:
18067 
        if ftype == TType.I64:
18068 
          self.providerId = iprot.readI64();
18069 
        else:
18070 
          iprot.skip(ftype)
18071 
      else:
18072 
        iprot.skip(ftype)
18073 
      iprot.readFieldEnd()
18074 
    iprot.readStructEnd()
18075 
 
18076 
  def write(self, oprot):
18077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18079 
      return
18080 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18081 
    if self.providerId is not None:
18082 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18083 
      oprot.writeI64(self.providerId)
18084 
      oprot.writeFieldEnd()
18085 
    oprot.writeFieldStop()
18086 
    oprot.writeStructEnd()
18087 
 
18088 
  def validate(self):
18089 
    return
18090 
 
18091 
 
18092 
  def __repr__(self):
18093 
    L = ['%s=%r' % (key, value)
18094 
      for key, value in self.__dict__.iteritems()]
18095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18096 
 
18097 
  def __eq__(self, other):
18098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18099 
 
18100 
  def __ne__(self, other):
18101 
    return not (self == other)
18102 
 
18103 
class getReturnOrdersNotPickedUp_result:
18104 
  """
18105 
  Attributes:
4741 phani.kuma 18106 
   - success
18107 
  """
18108 
 
18109 
  thrift_spec = (
18110 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18111 
  )
18112 
 
18113 
  def __init__(self, success=None,):
18114 
    self.success = success
18115 
 
18116 
  def read(self, iprot):
18117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18119 
      return
18120 
    iprot.readStructBegin()
18121 
    while True:
18122 
      (fname, ftype, fid) = iprot.readFieldBegin()
18123 
      if ftype == TType.STOP:
18124 
        break
18125 
      if fid == 0:
18126 
        if ftype == TType.LIST:
18127 
          self.success = []
6188 rajveer 18128 
          (_etype435, _size432) = iprot.readListBegin()
18129 
          for _i436 in xrange(_size432):
18130 
            _elem437 = Order()
18131 
            _elem437.read(iprot)
18132 
            self.success.append(_elem437)
4741 phani.kuma 18133 
          iprot.readListEnd()
18134 
        else:
18135 
          iprot.skip(ftype)
18136 
      else:
18137 
        iprot.skip(ftype)
18138 
      iprot.readFieldEnd()
18139 
    iprot.readStructEnd()
18140 
 
18141 
  def write(self, oprot):
18142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18144 
      return
4910 phani.kuma 18145 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18146 
    if self.success is not None:
18147 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18148 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18149 
      for iter438 in self.success:
18150 
        iter438.write(oprot)
4741 phani.kuma 18151 
      oprot.writeListEnd()
18152 
      oprot.writeFieldEnd()
18153 
    oprot.writeFieldStop()
18154 
    oprot.writeStructEnd()
18155 
 
18156 
  def validate(self):
18157 
    return
18158 
 
18159 
 
18160 
  def __repr__(self):
18161 
    L = ['%s=%r' % (key, value)
18162 
      for key, value in self.__dict__.iteritems()]
18163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18164 
 
18165 
  def __eq__(self, other):
18166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18167 
 
18168 
  def __ne__(self, other):
18169 
    return not (self == other)
18170 
 
2616 chandransh 18171 
class receiveReturn_args:
2591 chandransh 18172 
  """
18173 
  Attributes:
18174 
   - orderId
4479 rajveer 18175 
   - receiveCondition
2591 chandransh 18176 
  """
2536 chandransh 18177 
 
2591 chandransh 18178 
  thrift_spec = (
18179 
    None, # 0
18180 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18181 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18182 
  )
18183 
 
4479 rajveer 18184 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18185 
    self.orderId = orderId
4479 rajveer 18186 
    self.receiveCondition = receiveCondition
2591 chandransh 18187 
 
18188 
  def read(self, iprot):
18189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18191 
      return
18192 
    iprot.readStructBegin()
18193 
    while True:
18194 
      (fname, ftype, fid) = iprot.readFieldBegin()
18195 
      if ftype == TType.STOP:
18196 
        break
18197 
      if fid == 1:
18198 
        if ftype == TType.I64:
18199 
          self.orderId = iprot.readI64();
18200 
        else:
18201 
          iprot.skip(ftype)
4479 rajveer 18202 
      elif fid == 2:
18203 
        if ftype == TType.I64:
18204 
          self.receiveCondition = iprot.readI64();
18205 
        else:
18206 
          iprot.skip(ftype)
2591 chandransh 18207 
      else:
18208 
        iprot.skip(ftype)
18209 
      iprot.readFieldEnd()
18210 
    iprot.readStructEnd()
18211 
 
18212 
  def write(self, oprot):
18213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18215 
      return
2616 chandransh 18216 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18217 
    if self.orderId is not None:
2591 chandransh 18218 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18219 
      oprot.writeI64(self.orderId)
18220 
      oprot.writeFieldEnd()
4479 rajveer 18221 
    if self.receiveCondition is not None:
18222 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18223 
      oprot.writeI64(self.receiveCondition)
18224 
      oprot.writeFieldEnd()
2591 chandransh 18225 
    oprot.writeFieldStop()
18226 
    oprot.writeStructEnd()
18227 
 
3431 rajveer 18228 
  def validate(self):
18229 
    return
18230 
 
18231 
 
2591 chandransh 18232 
  def __repr__(self):
18233 
    L = ['%s=%r' % (key, value)
18234 
      for key, value in self.__dict__.iteritems()]
18235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18236 
 
18237 
  def __eq__(self, other):
18238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18239 
 
18240 
  def __ne__(self, other):
18241 
    return not (self == other)
18242 
 
2616 chandransh 18243 
class receiveReturn_result:
2591 chandransh 18244 
  """
18245 
  Attributes:
18246 
   - success
18247 
   - ex
18248 
  """
18249 
 
18250 
  thrift_spec = (
18251 
    (0, TType.BOOL, 'success', None, None, ), # 0
18252 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18253 
  )
18254 
 
18255 
  def __init__(self, success=None, ex=None,):
18256 
    self.success = success
18257 
    self.ex = ex
18258 
 
18259 
  def read(self, iprot):
18260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18262 
      return
18263 
    iprot.readStructBegin()
18264 
    while True:
18265 
      (fname, ftype, fid) = iprot.readFieldBegin()
18266 
      if ftype == TType.STOP:
18267 
        break
18268 
      if fid == 0:
18269 
        if ftype == TType.BOOL:
18270 
          self.success = iprot.readBool();
18271 
        else:
18272 
          iprot.skip(ftype)
18273 
      elif fid == 1:
18274 
        if ftype == TType.STRUCT:
18275 
          self.ex = TransactionServiceException()
18276 
          self.ex.read(iprot)
18277 
        else:
18278 
          iprot.skip(ftype)
18279 
      else:
18280 
        iprot.skip(ftype)
18281 
      iprot.readFieldEnd()
18282 
    iprot.readStructEnd()
18283 
 
18284 
  def write(self, oprot):
18285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18287 
      return
2616 chandransh 18288 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18289 
    if self.success is not None:
2591 chandransh 18290 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18291 
      oprot.writeBool(self.success)
18292 
      oprot.writeFieldEnd()
3431 rajveer 18293 
    if self.ex is not None:
2591 chandransh 18294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18295 
      self.ex.write(oprot)
18296 
      oprot.writeFieldEnd()
18297 
    oprot.writeFieldStop()
18298 
    oprot.writeStructEnd()
18299 
 
3431 rajveer 18300 
  def validate(self):
18301 
    return
18302 
 
18303 
 
2591 chandransh 18304 
  def __repr__(self):
18305 
    L = ['%s=%r' % (key, value)
18306 
      for key, value in self.__dict__.iteritems()]
18307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18308 
 
18309 
  def __eq__(self, other):
18310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18311 
 
18312 
  def __ne__(self, other):
18313 
    return not (self == other)
18314 
 
18315 
class validateDoa_args:
18316 
  """
18317 
  Attributes:
18318 
   - orderId
18319 
   - isValid
18320 
  """
18321 
 
18322 
  thrift_spec = (
18323 
    None, # 0
18324 
    (1, TType.I64, 'orderId', None, None, ), # 1
18325 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18326 
  )
18327 
 
18328 
  def __init__(self, orderId=None, isValid=None,):
18329 
    self.orderId = orderId
18330 
    self.isValid = isValid
18331 
 
18332 
  def read(self, iprot):
18333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18335 
      return
18336 
    iprot.readStructBegin()
18337 
    while True:
18338 
      (fname, ftype, fid) = iprot.readFieldBegin()
18339 
      if ftype == TType.STOP:
18340 
        break
18341 
      if fid == 1:
18342 
        if ftype == TType.I64:
18343 
          self.orderId = iprot.readI64();
18344 
        else:
18345 
          iprot.skip(ftype)
18346 
      elif fid == 2:
18347 
        if ftype == TType.BOOL:
18348 
          self.isValid = iprot.readBool();
18349 
        else:
18350 
          iprot.skip(ftype)
18351 
      else:
18352 
        iprot.skip(ftype)
18353 
      iprot.readFieldEnd()
18354 
    iprot.readStructEnd()
18355 
 
18356 
  def write(self, oprot):
18357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18359 
      return
18360 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18361 
    if self.orderId is not None:
2591 chandransh 18362 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18363 
      oprot.writeI64(self.orderId)
18364 
      oprot.writeFieldEnd()
3431 rajveer 18365 
    if self.isValid is not None:
2591 chandransh 18366 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18367 
      oprot.writeBool(self.isValid)
18368 
      oprot.writeFieldEnd()
18369 
    oprot.writeFieldStop()
18370 
    oprot.writeStructEnd()
18371 
 
3431 rajveer 18372 
  def validate(self):
18373 
    return
18374 
 
18375 
 
2591 chandransh 18376 
  def __repr__(self):
18377 
    L = ['%s=%r' % (key, value)
18378 
      for key, value in self.__dict__.iteritems()]
18379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18380 
 
18381 
  def __eq__(self, other):
18382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18383 
 
18384 
  def __ne__(self, other):
18385 
    return not (self == other)
18386 
 
18387 
class validateDoa_result:
18388 
  """
18389 
  Attributes:
18390 
   - success
18391 
   - ex
18392 
  """
18393 
 
18394 
  thrift_spec = (
18395 
    (0, TType.BOOL, 'success', None, None, ), # 0
18396 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18397 
  )
18398 
 
18399 
  def __init__(self, success=None, ex=None,):
18400 
    self.success = success
18401 
    self.ex = ex
18402 
 
18403 
  def read(self, iprot):
18404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18406 
      return
18407 
    iprot.readStructBegin()
18408 
    while True:
18409 
      (fname, ftype, fid) = iprot.readFieldBegin()
18410 
      if ftype == TType.STOP:
18411 
        break
18412 
      if fid == 0:
18413 
        if ftype == TType.BOOL:
18414 
          self.success = iprot.readBool();
18415 
        else:
18416 
          iprot.skip(ftype)
18417 
      elif fid == 1:
18418 
        if ftype == TType.STRUCT:
18419 
          self.ex = TransactionServiceException()
18420 
          self.ex.read(iprot)
18421 
        else:
18422 
          iprot.skip(ftype)
18423 
      else:
18424 
        iprot.skip(ftype)
18425 
      iprot.readFieldEnd()
18426 
    iprot.readStructEnd()
18427 
 
18428 
  def write(self, oprot):
18429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18431 
      return
18432 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18433 
    if self.success is not None:
2591 chandransh 18434 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18435 
      oprot.writeBool(self.success)
18436 
      oprot.writeFieldEnd()
3431 rajveer 18437 
    if self.ex is not None:
2591 chandransh 18438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18439 
      self.ex.write(oprot)
18440 
      oprot.writeFieldEnd()
18441 
    oprot.writeFieldStop()
18442 
    oprot.writeStructEnd()
18443 
 
3431 rajveer 18444 
  def validate(self):
18445 
    return
18446 
 
18447 
 
2591 chandransh 18448 
  def __repr__(self):
18449 
    L = ['%s=%r' % (key, value)
18450 
      for key, value in self.__dict__.iteritems()]
18451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18452 
 
18453 
  def __eq__(self, other):
18454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18455 
 
18456 
  def __ne__(self, other):
18457 
    return not (self == other)
18458 
 
4495 rajveer 18459 
class validateReturnProduct_args:
18460 
  """
18461 
  Attributes:
18462 
   - orderId
18463 
   - isUsable
18464 
  """
18465 
 
18466 
  thrift_spec = (
18467 
    None, # 0
18468 
    (1, TType.I64, 'orderId', None, None, ), # 1
18469 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18470 
  )
18471 
 
18472 
  def __init__(self, orderId=None, isUsable=None,):
18473 
    self.orderId = orderId
18474 
    self.isUsable = isUsable
18475 
 
18476 
  def read(self, iprot):
18477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18479 
      return
18480 
    iprot.readStructBegin()
18481 
    while True:
18482 
      (fname, ftype, fid) = iprot.readFieldBegin()
18483 
      if ftype == TType.STOP:
18484 
        break
18485 
      if fid == 1:
18486 
        if ftype == TType.I64:
18487 
          self.orderId = iprot.readI64();
18488 
        else:
18489 
          iprot.skip(ftype)
18490 
      elif fid == 2:
18491 
        if ftype == TType.BOOL:
18492 
          self.isUsable = iprot.readBool();
18493 
        else:
18494 
          iprot.skip(ftype)
18495 
      else:
18496 
        iprot.skip(ftype)
18497 
      iprot.readFieldEnd()
18498 
    iprot.readStructEnd()
18499 
 
18500 
  def write(self, oprot):
18501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18503 
      return
18504 
    oprot.writeStructBegin('validateReturnProduct_args')
18505 
    if self.orderId is not None:
18506 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18507 
      oprot.writeI64(self.orderId)
18508 
      oprot.writeFieldEnd()
18509 
    if self.isUsable is not None:
18510 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18511 
      oprot.writeBool(self.isUsable)
18512 
      oprot.writeFieldEnd()
18513 
    oprot.writeFieldStop()
18514 
    oprot.writeStructEnd()
18515 
 
18516 
  def validate(self):
18517 
    return
18518 
 
18519 
 
18520 
  def __repr__(self):
18521 
    L = ['%s=%r' % (key, value)
18522 
      for key, value in self.__dict__.iteritems()]
18523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18524 
 
18525 
  def __eq__(self, other):
18526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18527 
 
18528 
  def __ne__(self, other):
18529 
    return not (self == other)
18530 
 
18531 
class validateReturnProduct_result:
18532 
  """
18533 
  Attributes:
18534 
   - success
18535 
   - ex
18536 
  """
18537 
 
18538 
  thrift_spec = (
18539 
    (0, TType.BOOL, 'success', None, None, ), # 0
18540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18541 
  )
18542 
 
18543 
  def __init__(self, success=None, ex=None,):
18544 
    self.success = success
18545 
    self.ex = ex
18546 
 
18547 
  def read(self, iprot):
18548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18550 
      return
18551 
    iprot.readStructBegin()
18552 
    while True:
18553 
      (fname, ftype, fid) = iprot.readFieldBegin()
18554 
      if ftype == TType.STOP:
18555 
        break
18556 
      if fid == 0:
18557 
        if ftype == TType.BOOL:
18558 
          self.success = iprot.readBool();
18559 
        else:
18560 
          iprot.skip(ftype)
18561 
      elif fid == 1:
18562 
        if ftype == TType.STRUCT:
18563 
          self.ex = TransactionServiceException()
18564 
          self.ex.read(iprot)
18565 
        else:
18566 
          iprot.skip(ftype)
18567 
      else:
18568 
        iprot.skip(ftype)
18569 
      iprot.readFieldEnd()
18570 
    iprot.readStructEnd()
18571 
 
18572 
  def write(self, oprot):
18573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18575 
      return
18576 
    oprot.writeStructBegin('validateReturnProduct_result')
18577 
    if self.success is not None:
18578 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18579 
      oprot.writeBool(self.success)
18580 
      oprot.writeFieldEnd()
18581 
    if self.ex is not None:
18582 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18583 
      self.ex.write(oprot)
18584 
      oprot.writeFieldEnd()
18585 
    oprot.writeFieldStop()
18586 
    oprot.writeStructEnd()
18587 
 
18588 
  def validate(self):
18589 
    return
18590 
 
18591 
 
18592 
  def __repr__(self):
18593 
    L = ['%s=%r' % (key, value)
18594 
      for key, value in self.__dict__.iteritems()]
18595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18596 
 
18597 
  def __eq__(self, other):
18598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18599 
 
18600 
  def __ne__(self, other):
18601 
    return not (self == other)
18602 
 
2616 chandransh 18603 
class reshipOrder_args:
18604 
  """
18605 
  Attributes:
18606 
   - orderId
18607 
  """
2591 chandransh 18608 
 
2616 chandransh 18609 
  thrift_spec = (
18610 
    None, # 0
18611 
    (1, TType.I64, 'orderId', None, None, ), # 1
18612 
  )
18613 
 
18614 
  def __init__(self, orderId=None,):
18615 
    self.orderId = orderId
18616 
 
18617 
  def read(self, iprot):
18618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18620 
      return
18621 
    iprot.readStructBegin()
18622 
    while True:
18623 
      (fname, ftype, fid) = iprot.readFieldBegin()
18624 
      if ftype == TType.STOP:
18625 
        break
18626 
      if fid == 1:
18627 
        if ftype == TType.I64:
18628 
          self.orderId = iprot.readI64();
18629 
        else:
18630 
          iprot.skip(ftype)
18631 
      else:
18632 
        iprot.skip(ftype)
18633 
      iprot.readFieldEnd()
18634 
    iprot.readStructEnd()
18635 
 
18636 
  def write(self, oprot):
18637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18639 
      return
18640 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18641 
    if self.orderId is not None:
2616 chandransh 18642 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18643 
      oprot.writeI64(self.orderId)
18644 
      oprot.writeFieldEnd()
18645 
    oprot.writeFieldStop()
18646 
    oprot.writeStructEnd()
18647 
 
3431 rajveer 18648 
  def validate(self):
18649 
    return
18650 
 
18651 
 
2616 chandransh 18652 
  def __repr__(self):
18653 
    L = ['%s=%r' % (key, value)
18654 
      for key, value in self.__dict__.iteritems()]
18655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18656 
 
18657 
  def __eq__(self, other):
18658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18659 
 
18660 
  def __ne__(self, other):
18661 
    return not (self == other)
18662 
 
18663 
class reshipOrder_result:
18664 
  """
18665 
  Attributes:
18666 
   - success
18667 
   - ex
18668 
  """
18669 
 
18670 
  thrift_spec = (
18671 
    (0, TType.I64, 'success', None, None, ), # 0
18672 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18673 
  )
18674 
 
18675 
  def __init__(self, success=None, ex=None,):
18676 
    self.success = success
18677 
    self.ex = ex
18678 
 
18679 
  def read(self, iprot):
18680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18682 
      return
18683 
    iprot.readStructBegin()
18684 
    while True:
18685 
      (fname, ftype, fid) = iprot.readFieldBegin()
18686 
      if ftype == TType.STOP:
18687 
        break
18688 
      if fid == 0:
18689 
        if ftype == TType.I64:
18690 
          self.success = iprot.readI64();
18691 
        else:
18692 
          iprot.skip(ftype)
18693 
      elif fid == 1:
18694 
        if ftype == TType.STRUCT:
18695 
          self.ex = TransactionServiceException()
18696 
          self.ex.read(iprot)
18697 
        else:
18698 
          iprot.skip(ftype)
18699 
      else:
18700 
        iprot.skip(ftype)
18701 
      iprot.readFieldEnd()
18702 
    iprot.readStructEnd()
18703 
 
18704 
  def write(self, oprot):
18705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18707 
      return
18708 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18709 
    if self.success is not None:
2616 chandransh 18710 
      oprot.writeFieldBegin('success', TType.I64, 0)
18711 
      oprot.writeI64(self.success)
18712 
      oprot.writeFieldEnd()
3431 rajveer 18713 
    if self.ex is not None:
2616 chandransh 18714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18715 
      self.ex.write(oprot)
18716 
      oprot.writeFieldEnd()
18717 
    oprot.writeFieldStop()
18718 
    oprot.writeStructEnd()
18719 
 
3431 rajveer 18720 
  def validate(self):
18721 
    return
18722 
 
18723 
 
2616 chandransh 18724 
  def __repr__(self):
18725 
    L = ['%s=%r' % (key, value)
18726 
      for key, value in self.__dict__.iteritems()]
18727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18728 
 
18729 
  def __eq__(self, other):
18730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18731 
 
18732 
  def __ne__(self, other):
18733 
    return not (self == other)
18734 
 
18735 
class refundOrder_args:
18736 
  """
18737 
  Attributes:
18738 
   - orderId
3226 chandransh 18739 
   - refundedBy
18740 
   - reason
2616 chandransh 18741 
  """
18742 
 
18743 
  thrift_spec = (
18744 
    None, # 0
18745 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18746 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18747 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18748 
  )
18749 
 
3226 chandransh 18750 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18751 
    self.orderId = orderId
3226 chandransh 18752 
    self.refundedBy = refundedBy
18753 
    self.reason = reason
2616 chandransh 18754 
 
18755 
  def read(self, iprot):
18756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18758 
      return
18759 
    iprot.readStructBegin()
18760 
    while True:
18761 
      (fname, ftype, fid) = iprot.readFieldBegin()
18762 
      if ftype == TType.STOP:
18763 
        break
18764 
      if fid == 1:
18765 
        if ftype == TType.I64:
18766 
          self.orderId = iprot.readI64();
18767 
        else:
18768 
          iprot.skip(ftype)
3226 chandransh 18769 
      elif fid == 2:
18770 
        if ftype == TType.STRING:
18771 
          self.refundedBy = iprot.readString();
18772 
        else:
18773 
          iprot.skip(ftype)
18774 
      elif fid == 3:
18775 
        if ftype == TType.STRING:
18776 
          self.reason = iprot.readString();
18777 
        else:
18778 
          iprot.skip(ftype)
2616 chandransh 18779 
      else:
18780 
        iprot.skip(ftype)
18781 
      iprot.readFieldEnd()
18782 
    iprot.readStructEnd()
18783 
 
18784 
  def write(self, oprot):
18785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18787 
      return
18788 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18789 
    if self.orderId is not None:
2616 chandransh 18790 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18791 
      oprot.writeI64(self.orderId)
18792 
      oprot.writeFieldEnd()
3431 rajveer 18793 
    if self.refundedBy is not None:
3226 chandransh 18794 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18795 
      oprot.writeString(self.refundedBy)
18796 
      oprot.writeFieldEnd()
3431 rajveer 18797 
    if self.reason is not None:
3226 chandransh 18798 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18799 
      oprot.writeString(self.reason)
18800 
      oprot.writeFieldEnd()
2616 chandransh 18801 
    oprot.writeFieldStop()
18802 
    oprot.writeStructEnd()
18803 
 
3431 rajveer 18804 
  def validate(self):
18805 
    return
18806 
 
18807 
 
2616 chandransh 18808 
  def __repr__(self):
18809 
    L = ['%s=%r' % (key, value)
18810 
      for key, value in self.__dict__.iteritems()]
18811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18812 
 
18813 
  def __eq__(self, other):
18814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18815 
 
18816 
  def __ne__(self, other):
18817 
    return not (self == other)
18818 
 
18819 
class refundOrder_result:
18820 
  """
18821 
  Attributes:
18822 
   - success
18823 
   - ex
18824 
  """
18825 
 
18826 
  thrift_spec = (
18827 
    (0, TType.BOOL, 'success', None, None, ), # 0
18828 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18829 
  )
18830 
 
18831 
  def __init__(self, success=None, ex=None,):
18832 
    self.success = success
18833 
    self.ex = ex
18834 
 
18835 
  def read(self, iprot):
18836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18838 
      return
18839 
    iprot.readStructBegin()
18840 
    while True:
18841 
      (fname, ftype, fid) = iprot.readFieldBegin()
18842 
      if ftype == TType.STOP:
18843 
        break
18844 
      if fid == 0:
18845 
        if ftype == TType.BOOL:
18846 
          self.success = iprot.readBool();
18847 
        else:
18848 
          iprot.skip(ftype)
18849 
      elif fid == 1:
18850 
        if ftype == TType.STRUCT:
18851 
          self.ex = TransactionServiceException()
18852 
          self.ex.read(iprot)
18853 
        else:
18854 
          iprot.skip(ftype)
18855 
      else:
18856 
        iprot.skip(ftype)
18857 
      iprot.readFieldEnd()
18858 
    iprot.readStructEnd()
18859 
 
18860 
  def write(self, oprot):
18861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18863 
      return
18864 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18865 
    if self.success is not None:
2616 chandransh 18866 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18867 
      oprot.writeBool(self.success)
18868 
      oprot.writeFieldEnd()
3431 rajveer 18869 
    if self.ex is not None:
2616 chandransh 18870 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18871 
      self.ex.write(oprot)
18872 
      oprot.writeFieldEnd()
18873 
    oprot.writeFieldStop()
18874 
    oprot.writeStructEnd()
18875 
 
3431 rajveer 18876 
  def validate(self):
18877 
    return
18878 
 
18879 
 
2616 chandransh 18880 
  def __repr__(self):
18881 
    L = ['%s=%r' % (key, value)
18882 
      for key, value in self.__dict__.iteritems()]
18883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18884 
 
18885 
  def __eq__(self, other):
18886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18887 
 
18888 
  def __ne__(self, other):
18889 
    return not (self == other)
18890 
 
2690 chandransh 18891 
class getReturnOrders_args:
18892 
  """
18893 
  Attributes:
18894 
   - warehouseId
18895 
   - fromDate
18896 
   - toDate
18897 
  """
2616 chandransh 18898 
 
2690 chandransh 18899 
  thrift_spec = (
18900 
    None, # 0
18901 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18902 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18903 
    (3, TType.I64, 'toDate', None, None, ), # 3
18904 
  )
18905 
 
18906 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18907 
    self.warehouseId = warehouseId
18908 
    self.fromDate = fromDate
18909 
    self.toDate = toDate
18910 
 
18911 
  def read(self, iprot):
18912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18914 
      return
18915 
    iprot.readStructBegin()
18916 
    while True:
18917 
      (fname, ftype, fid) = iprot.readFieldBegin()
18918 
      if ftype == TType.STOP:
18919 
        break
18920 
      if fid == 1:
18921 
        if ftype == TType.I64:
18922 
          self.warehouseId = iprot.readI64();
18923 
        else:
18924 
          iprot.skip(ftype)
18925 
      elif fid == 2:
18926 
        if ftype == TType.I64:
18927 
          self.fromDate = iprot.readI64();
18928 
        else:
18929 
          iprot.skip(ftype)
18930 
      elif fid == 3:
18931 
        if ftype == TType.I64:
18932 
          self.toDate = iprot.readI64();
18933 
        else:
18934 
          iprot.skip(ftype)
18935 
      else:
18936 
        iprot.skip(ftype)
18937 
      iprot.readFieldEnd()
18938 
    iprot.readStructEnd()
18939 
 
18940 
  def write(self, oprot):
18941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18943 
      return
18944 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18945 
    if self.warehouseId is not None:
2690 chandransh 18946 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18947 
      oprot.writeI64(self.warehouseId)
18948 
      oprot.writeFieldEnd()
3431 rajveer 18949 
    if self.fromDate is not None:
2690 chandransh 18950 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18951 
      oprot.writeI64(self.fromDate)
18952 
      oprot.writeFieldEnd()
3431 rajveer 18953 
    if self.toDate is not None:
2690 chandransh 18954 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18955 
      oprot.writeI64(self.toDate)
18956 
      oprot.writeFieldEnd()
18957 
    oprot.writeFieldStop()
18958 
    oprot.writeStructEnd()
18959 
 
3431 rajveer 18960 
  def validate(self):
18961 
    return
18962 
 
18963 
 
2690 chandransh 18964 
  def __repr__(self):
18965 
    L = ['%s=%r' % (key, value)
18966 
      for key, value in self.__dict__.iteritems()]
18967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18968 
 
18969 
  def __eq__(self, other):
18970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18971 
 
18972 
  def __ne__(self, other):
18973 
    return not (self == other)
18974 
 
18975 
class getReturnOrders_result:
18976 
  """
18977 
  Attributes:
18978 
   - success
18979 
  """
18980 
 
18981 
  thrift_spec = (
18982 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18983 
  )
18984 
 
18985 
  def __init__(self, success=None,):
18986 
    self.success = success
18987 
 
18988 
  def read(self, iprot):
18989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18991 
      return
18992 
    iprot.readStructBegin()
18993 
    while True:
18994 
      (fname, ftype, fid) = iprot.readFieldBegin()
18995 
      if ftype == TType.STOP:
18996 
        break
18997 
      if fid == 0:
18998 
        if ftype == TType.LIST:
18999 
          self.success = []
6188 rajveer 19000 
          (_etype442, _size439) = iprot.readListBegin()
19001 
          for _i443 in xrange(_size439):
19002 
            _elem444 = ReturnOrder()
19003 
            _elem444.read(iprot)
19004 
            self.success.append(_elem444)
2690 chandransh 19005 
          iprot.readListEnd()
19006 
        else:
19007 
          iprot.skip(ftype)
19008 
      else:
19009 
        iprot.skip(ftype)
19010 
      iprot.readFieldEnd()
19011 
    iprot.readStructEnd()
19012 
 
19013 
  def write(self, oprot):
19014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19016 
      return
19017 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19018 
    if self.success is not None:
2690 chandransh 19019 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19020 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19021 
      for iter445 in self.success:
19022 
        iter445.write(oprot)
2690 chandransh 19023 
      oprot.writeListEnd()
19024 
      oprot.writeFieldEnd()
19025 
    oprot.writeFieldStop()
19026 
    oprot.writeStructEnd()
19027 
 
3431 rajveer 19028 
  def validate(self):
19029 
    return
19030 
 
19031 
 
2690 chandransh 19032 
  def __repr__(self):
19033 
    L = ['%s=%r' % (key, value)
19034 
      for key, value in self.__dict__.iteritems()]
19035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19036 
 
19037 
  def __eq__(self, other):
19038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19039 
 
19040 
  def __ne__(self, other):
19041 
    return not (self == other)
19042 
 
5481 phani.kuma 19043 
class getAllReturnOrders_args:
19044 
  """
19045 
  Attributes:
19046 
   - onlyNotProcessed
19047 
   - fromDate
19048 
   - toDate
19049 
  """
19050 
 
19051 
  thrift_spec = (
19052 
    None, # 0
19053 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19054 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19055 
    (3, TType.I64, 'toDate', None, None, ), # 3
19056 
  )
19057 
 
19058 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19059 
    self.onlyNotProcessed = onlyNotProcessed
19060 
    self.fromDate = fromDate
19061 
    self.toDate = toDate
19062 
 
19063 
  def read(self, iprot):
19064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19066 
      return
19067 
    iprot.readStructBegin()
19068 
    while True:
19069 
      (fname, ftype, fid) = iprot.readFieldBegin()
19070 
      if ftype == TType.STOP:
19071 
        break
19072 
      if fid == 1:
19073 
        if ftype == TType.BOOL:
19074 
          self.onlyNotProcessed = iprot.readBool();
19075 
        else:
19076 
          iprot.skip(ftype)
19077 
      elif fid == 2:
19078 
        if ftype == TType.I64:
19079 
          self.fromDate = iprot.readI64();
19080 
        else:
19081 
          iprot.skip(ftype)
19082 
      elif fid == 3:
19083 
        if ftype == TType.I64:
19084 
          self.toDate = iprot.readI64();
19085 
        else:
19086 
          iprot.skip(ftype)
19087 
      else:
19088 
        iprot.skip(ftype)
19089 
      iprot.readFieldEnd()
19090 
    iprot.readStructEnd()
19091 
 
19092 
  def write(self, oprot):
19093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19095 
      return
19096 
    oprot.writeStructBegin('getAllReturnOrders_args')
19097 
    if self.onlyNotProcessed is not None:
19098 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19099 
      oprot.writeBool(self.onlyNotProcessed)
19100 
      oprot.writeFieldEnd()
19101 
    if self.fromDate is not None:
19102 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19103 
      oprot.writeI64(self.fromDate)
19104 
      oprot.writeFieldEnd()
19105 
    if self.toDate is not None:
19106 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19107 
      oprot.writeI64(self.toDate)
19108 
      oprot.writeFieldEnd()
19109 
    oprot.writeFieldStop()
19110 
    oprot.writeStructEnd()
19111 
 
19112 
  def validate(self):
19113 
    return
19114 
 
19115 
 
19116 
  def __repr__(self):
19117 
    L = ['%s=%r' % (key, value)
19118 
      for key, value in self.__dict__.iteritems()]
19119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19120 
 
19121 
  def __eq__(self, other):
19122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19123 
 
19124 
  def __ne__(self, other):
19125 
    return not (self == other)
19126 
 
19127 
class getAllReturnOrders_result:
19128 
  """
19129 
  Attributes:
19130 
   - success
19131 
  """
19132 
 
19133 
  thrift_spec = (
19134 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19135 
  )
19136 
 
19137 
  def __init__(self, success=None,):
19138 
    self.success = success
19139 
 
19140 
  def read(self, iprot):
19141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19143 
      return
19144 
    iprot.readStructBegin()
19145 
    while True:
19146 
      (fname, ftype, fid) = iprot.readFieldBegin()
19147 
      if ftype == TType.STOP:
19148 
        break
19149 
      if fid == 0:
19150 
        if ftype == TType.LIST:
19151 
          self.success = []
6188 rajveer 19152 
          (_etype449, _size446) = iprot.readListBegin()
19153 
          for _i450 in xrange(_size446):
19154 
            _elem451 = ReturnOrder()
19155 
            _elem451.read(iprot)
19156 
            self.success.append(_elem451)
5481 phani.kuma 19157 
          iprot.readListEnd()
19158 
        else:
19159 
          iprot.skip(ftype)
19160 
      else:
19161 
        iprot.skip(ftype)
19162 
      iprot.readFieldEnd()
19163 
    iprot.readStructEnd()
19164 
 
19165 
  def write(self, oprot):
19166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19168 
      return
19169 
    oprot.writeStructBegin('getAllReturnOrders_result')
19170 
    if self.success is not None:
19171 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19172 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19173 
      for iter452 in self.success:
19174 
        iter452.write(oprot)
5481 phani.kuma 19175 
      oprot.writeListEnd()
19176 
      oprot.writeFieldEnd()
19177 
    oprot.writeFieldStop()
19178 
    oprot.writeStructEnd()
19179 
 
19180 
  def validate(self):
19181 
    return
19182 
 
19183 
 
19184 
  def __repr__(self):
19185 
    L = ['%s=%r' % (key, value)
19186 
      for key, value in self.__dict__.iteritems()]
19187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19188 
 
19189 
  def __eq__(self, other):
19190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19191 
 
19192 
  def __ne__(self, other):
19193 
    return not (self == other)
19194 
 
2700 chandransh 19195 
class getReturnOrder_args:
19196 
  """
19197 
  Attributes:
19198 
   - id
19199 
  """
19200 
 
19201 
  thrift_spec = (
19202 
    None, # 0
19203 
    (1, TType.I64, 'id', None, None, ), # 1
19204 
  )
19205 
 
19206 
  def __init__(self, id=None,):
19207 
    self.id = id
19208 
 
19209 
  def read(self, iprot):
19210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19212 
      return
19213 
    iprot.readStructBegin()
19214 
    while True:
19215 
      (fname, ftype, fid) = iprot.readFieldBegin()
19216 
      if ftype == TType.STOP:
19217 
        break
19218 
      if fid == 1:
19219 
        if ftype == TType.I64:
19220 
          self.id = iprot.readI64();
19221 
        else:
19222 
          iprot.skip(ftype)
19223 
      else:
19224 
        iprot.skip(ftype)
19225 
      iprot.readFieldEnd()
19226 
    iprot.readStructEnd()
19227 
 
19228 
  def write(self, oprot):
19229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19231 
      return
19232 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19233 
    if self.id is not None:
2700 chandransh 19234 
      oprot.writeFieldBegin('id', TType.I64, 1)
19235 
      oprot.writeI64(self.id)
19236 
      oprot.writeFieldEnd()
19237 
    oprot.writeFieldStop()
19238 
    oprot.writeStructEnd()
19239 
 
3431 rajveer 19240 
  def validate(self):
19241 
    return
19242 
 
19243 
 
2700 chandransh 19244 
  def __repr__(self):
19245 
    L = ['%s=%r' % (key, value)
19246 
      for key, value in self.__dict__.iteritems()]
19247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19248 
 
19249 
  def __eq__(self, other):
19250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19251 
 
19252 
  def __ne__(self, other):
19253 
    return not (self == other)
19254 
 
19255 
class getReturnOrder_result:
19256 
  """
19257 
  Attributes:
19258 
   - success
19259 
   - ex
19260 
  """
19261 
 
19262 
  thrift_spec = (
19263 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19264 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19265 
  )
19266 
 
19267 
  def __init__(self, success=None, ex=None,):
19268 
    self.success = success
19269 
    self.ex = ex
19270 
 
19271 
  def read(self, iprot):
19272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19274 
      return
19275 
    iprot.readStructBegin()
19276 
    while True:
19277 
      (fname, ftype, fid) = iprot.readFieldBegin()
19278 
      if ftype == TType.STOP:
19279 
        break
19280 
      if fid == 0:
19281 
        if ftype == TType.STRUCT:
19282 
          self.success = ReturnOrder()
19283 
          self.success.read(iprot)
19284 
        else:
19285 
          iprot.skip(ftype)
19286 
      elif fid == 1:
19287 
        if ftype == TType.STRUCT:
19288 
          self.ex = TransactionServiceException()
19289 
          self.ex.read(iprot)
19290 
        else:
19291 
          iprot.skip(ftype)
19292 
      else:
19293 
        iprot.skip(ftype)
19294 
      iprot.readFieldEnd()
19295 
    iprot.readStructEnd()
19296 
 
19297 
  def write(self, oprot):
19298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19300 
      return
19301 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19302 
    if self.success is not None:
2700 chandransh 19303 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19304 
      self.success.write(oprot)
19305 
      oprot.writeFieldEnd()
3431 rajveer 19306 
    if self.ex is not None:
2700 chandransh 19307 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19308 
      self.ex.write(oprot)
19309 
      oprot.writeFieldEnd()
19310 
    oprot.writeFieldStop()
19311 
    oprot.writeStructEnd()
19312 
 
3431 rajveer 19313 
  def validate(self):
19314 
    return
19315 
 
19316 
 
2700 chandransh 19317 
  def __repr__(self):
19318 
    L = ['%s=%r' % (key, value)
19319 
      for key, value in self.__dict__.iteritems()]
19320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19321 
 
19322 
  def __eq__(self, other):
19323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19324 
 
19325 
  def __ne__(self, other):
19326 
    return not (self == other)
19327 
 
2690 chandransh 19328 
class processReturn_args:
19329 
  """
19330 
  Attributes:
19331 
   - returnOrderId
19332 
  """
19333 
 
19334 
  thrift_spec = (
19335 
    None, # 0
19336 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19337 
  )
19338 
 
19339 
  def __init__(self, returnOrderId=None,):
19340 
    self.returnOrderId = returnOrderId
19341 
 
19342 
  def read(self, iprot):
19343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19345 
      return
19346 
    iprot.readStructBegin()
19347 
    while True:
19348 
      (fname, ftype, fid) = iprot.readFieldBegin()
19349 
      if ftype == TType.STOP:
19350 
        break
19351 
      if fid == 1:
19352 
        if ftype == TType.I64:
19353 
          self.returnOrderId = iprot.readI64();
19354 
        else:
19355 
          iprot.skip(ftype)
19356 
      else:
19357 
        iprot.skip(ftype)
19358 
      iprot.readFieldEnd()
19359 
    iprot.readStructEnd()
19360 
 
19361 
  def write(self, oprot):
19362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19364 
      return
19365 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19366 
    if self.returnOrderId is not None:
2690 chandransh 19367 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19368 
      oprot.writeI64(self.returnOrderId)
19369 
      oprot.writeFieldEnd()
19370 
    oprot.writeFieldStop()
19371 
    oprot.writeStructEnd()
19372 
 
3431 rajveer 19373 
  def validate(self):
19374 
    return
19375 
 
19376 
 
2690 chandransh 19377 
  def __repr__(self):
19378 
    L = ['%s=%r' % (key, value)
19379 
      for key, value in self.__dict__.iteritems()]
19380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19381 
 
19382 
  def __eq__(self, other):
19383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19384 
 
19385 
  def __ne__(self, other):
19386 
    return not (self == other)
19387 
 
19388 
class processReturn_result:
19389 
  """
19390 
  Attributes:
19391 
   - ex
19392 
  """
19393 
 
19394 
  thrift_spec = (
19395 
    None, # 0
19396 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19397 
  )
19398 
 
19399 
  def __init__(self, ex=None,):
19400 
    self.ex = ex
19401 
 
19402 
  def read(self, iprot):
19403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19405 
      return
19406 
    iprot.readStructBegin()
19407 
    while True:
19408 
      (fname, ftype, fid) = iprot.readFieldBegin()
19409 
      if ftype == TType.STOP:
19410 
        break
19411 
      if fid == 1:
19412 
        if ftype == TType.STRUCT:
19413 
          self.ex = TransactionServiceException()
19414 
          self.ex.read(iprot)
19415 
        else:
19416 
          iprot.skip(ftype)
19417 
      else:
19418 
        iprot.skip(ftype)
19419 
      iprot.readFieldEnd()
19420 
    iprot.readStructEnd()
19421 
 
19422 
  def write(self, oprot):
19423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19425 
      return
19426 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19427 
    if self.ex is not None:
2690 chandransh 19428 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19429 
      self.ex.write(oprot)
19430 
      oprot.writeFieldEnd()
19431 
    oprot.writeFieldStop()
19432 
    oprot.writeStructEnd()
19433 
 
3431 rajveer 19434 
  def validate(self):
19435 
    return
19436 
 
19437 
 
2690 chandransh 19438 
  def __repr__(self):
19439 
    L = ['%s=%r' % (key, value)
19440 
      for key, value in self.__dict__.iteritems()]
19441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19442 
 
19443 
  def __eq__(self, other):
19444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19445 
 
19446 
  def __ne__(self, other):
19447 
    return not (self == other)
19448 
 
3451 chandransh 19449 
class updateWeight_args:
19450 
  """
19451 
  Attributes:
19452 
   - orderId
19453 
   - weight
19454 
  """
19455 
 
19456 
  thrift_spec = (
19457 
    None, # 0
19458 
    (1, TType.I64, 'orderId', None, None, ), # 1
19459 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19460 
  )
19461 
 
19462 
  def __init__(self, orderId=None, weight=None,):
19463 
    self.orderId = orderId
19464 
    self.weight = weight
19465 
 
19466 
  def read(self, iprot):
19467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19469 
      return
19470 
    iprot.readStructBegin()
19471 
    while True:
19472 
      (fname, ftype, fid) = iprot.readFieldBegin()
19473 
      if ftype == TType.STOP:
19474 
        break
19475 
      if fid == 1:
19476 
        if ftype == TType.I64:
19477 
          self.orderId = iprot.readI64();
19478 
        else:
19479 
          iprot.skip(ftype)
19480 
      elif fid == 2:
19481 
        if ftype == TType.DOUBLE:
19482 
          self.weight = iprot.readDouble();
19483 
        else:
19484 
          iprot.skip(ftype)
19485 
      else:
19486 
        iprot.skip(ftype)
19487 
      iprot.readFieldEnd()
19488 
    iprot.readStructEnd()
19489 
 
19490 
  def write(self, oprot):
19491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19493 
      return
19494 
    oprot.writeStructBegin('updateWeight_args')
19495 
    if self.orderId is not None:
19496 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19497 
      oprot.writeI64(self.orderId)
19498 
      oprot.writeFieldEnd()
19499 
    if self.weight is not None:
19500 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19501 
      oprot.writeDouble(self.weight)
19502 
      oprot.writeFieldEnd()
19503 
    oprot.writeFieldStop()
19504 
    oprot.writeStructEnd()
19505 
 
19506 
  def validate(self):
19507 
    return
19508 
 
19509 
 
19510 
  def __repr__(self):
19511 
    L = ['%s=%r' % (key, value)
19512 
      for key, value in self.__dict__.iteritems()]
19513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19514 
 
19515 
  def __eq__(self, other):
19516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19517 
 
19518 
  def __ne__(self, other):
19519 
    return not (self == other)
19520 
 
19521 
class updateWeight_result:
19522 
  """
19523 
  Attributes:
19524 
   - success
19525 
   - ex
19526 
  """
19527 
 
19528 
  thrift_spec = (
19529 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19530 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19531 
  )
19532 
 
19533 
  def __init__(self, success=None, ex=None,):
19534 
    self.success = success
19535 
    self.ex = ex
19536 
 
19537 
  def read(self, iprot):
19538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19540 
      return
19541 
    iprot.readStructBegin()
19542 
    while True:
19543 
      (fname, ftype, fid) = iprot.readFieldBegin()
19544 
      if ftype == TType.STOP:
19545 
        break
19546 
      if fid == 0:
19547 
        if ftype == TType.STRUCT:
19548 
          self.success = Order()
19549 
          self.success.read(iprot)
19550 
        else:
19551 
          iprot.skip(ftype)
19552 
      elif fid == 1:
19553 
        if ftype == TType.STRUCT:
19554 
          self.ex = TransactionServiceException()
19555 
          self.ex.read(iprot)
19556 
        else:
19557 
          iprot.skip(ftype)
19558 
      else:
19559 
        iprot.skip(ftype)
19560 
      iprot.readFieldEnd()
19561 
    iprot.readStructEnd()
19562 
 
19563 
  def write(self, oprot):
19564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19566 
      return
19567 
    oprot.writeStructBegin('updateWeight_result')
19568 
    if self.success is not None:
19569 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19570 
      self.success.write(oprot)
19571 
      oprot.writeFieldEnd()
19572 
    if self.ex is not None:
19573 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19574 
      self.ex.write(oprot)
19575 
      oprot.writeFieldEnd()
19576 
    oprot.writeFieldStop()
19577 
    oprot.writeStructEnd()
19578 
 
19579 
  def validate(self):
19580 
    return
19581 
 
19582 
 
19583 
  def __repr__(self):
19584 
    L = ['%s=%r' % (key, value)
19585 
      for key, value in self.__dict__.iteritems()]
19586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19587 
 
19588 
  def __eq__(self, other):
19589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19590 
 
19591 
  def __ne__(self, other):
19592 
    return not (self == other)
3469 chandransh 19593 
 
19594 
class changeItem_args:
19595 
  """
19596 
  Attributes:
19597 
   - orderId
19598 
   - itemId
19599 
  """
19600 
 
19601 
  thrift_spec = (
19602 
    None, # 0
19603 
    (1, TType.I64, 'orderId', None, None, ), # 1
19604 
    (2, TType.I64, 'itemId', None, None, ), # 2
19605 
  )
19606 
 
19607 
  def __init__(self, orderId=None, itemId=None,):
19608 
    self.orderId = orderId
19609 
    self.itemId = itemId
19610 
 
19611 
  def read(self, iprot):
19612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19614 
      return
19615 
    iprot.readStructBegin()
19616 
    while True:
19617 
      (fname, ftype, fid) = iprot.readFieldBegin()
19618 
      if ftype == TType.STOP:
19619 
        break
19620 
      if fid == 1:
19621 
        if ftype == TType.I64:
19622 
          self.orderId = iprot.readI64();
19623 
        else:
19624 
          iprot.skip(ftype)
19625 
      elif fid == 2:
19626 
        if ftype == TType.I64:
19627 
          self.itemId = iprot.readI64();
19628 
        else:
19629 
          iprot.skip(ftype)
19630 
      else:
19631 
        iprot.skip(ftype)
19632 
      iprot.readFieldEnd()
19633 
    iprot.readStructEnd()
19634 
 
19635 
  def write(self, oprot):
19636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19638 
      return
19639 
    oprot.writeStructBegin('changeItem_args')
19640 
    if self.orderId is not None:
19641 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19642 
      oprot.writeI64(self.orderId)
19643 
      oprot.writeFieldEnd()
19644 
    if self.itemId is not None:
19645 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19646 
      oprot.writeI64(self.itemId)
19647 
      oprot.writeFieldEnd()
19648 
    oprot.writeFieldStop()
19649 
    oprot.writeStructEnd()
19650 
 
19651 
  def validate(self):
19652 
    return
19653 
 
19654 
 
19655 
  def __repr__(self):
19656 
    L = ['%s=%r' % (key, value)
19657 
      for key, value in self.__dict__.iteritems()]
19658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19659 
 
19660 
  def __eq__(self, other):
19661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19662 
 
19663 
  def __ne__(self, other):
19664 
    return not (self == other)
19665 
 
19666 
class changeItem_result:
19667 
  """
19668 
  Attributes:
19669 
   - success
19670 
   - ex
19671 
  """
19672 
 
19673 
  thrift_spec = (
19674 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19676 
  )
19677 
 
19678 
  def __init__(self, success=None, ex=None,):
19679 
    self.success = success
19680 
    self.ex = ex
19681 
 
19682 
  def read(self, iprot):
19683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19685 
      return
19686 
    iprot.readStructBegin()
19687 
    while True:
19688 
      (fname, ftype, fid) = iprot.readFieldBegin()
19689 
      if ftype == TType.STOP:
19690 
        break
19691 
      if fid == 0:
19692 
        if ftype == TType.STRUCT:
19693 
          self.success = Order()
19694 
          self.success.read(iprot)
19695 
        else:
19696 
          iprot.skip(ftype)
19697 
      elif fid == 1:
19698 
        if ftype == TType.STRUCT:
19699 
          self.ex = TransactionServiceException()
19700 
          self.ex.read(iprot)
19701 
        else:
19702 
          iprot.skip(ftype)
19703 
      else:
19704 
        iprot.skip(ftype)
19705 
      iprot.readFieldEnd()
19706 
    iprot.readStructEnd()
19707 
 
19708 
  def write(self, oprot):
19709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19711 
      return
19712 
    oprot.writeStructBegin('changeItem_result')
19713 
    if self.success is not None:
19714 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19715 
      self.success.write(oprot)
19716 
      oprot.writeFieldEnd()
19717 
    if self.ex is not None:
19718 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19719 
      self.ex.write(oprot)
19720 
      oprot.writeFieldEnd()
19721 
    oprot.writeFieldStop()
19722 
    oprot.writeStructEnd()
19723 
 
19724 
  def validate(self):
19725 
    return
19726 
 
19727 
 
19728 
  def __repr__(self):
19729 
    L = ['%s=%r' % (key, value)
19730 
      for key, value in self.__dict__.iteritems()]
19731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19732 
 
19733 
  def __eq__(self, other):
19734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19735 
 
19736 
  def __ne__(self, other):
19737 
    return not (self == other)
19738 
 
19739 
class shiftToWarehouse_args:
19740 
  """
19741 
  Attributes:
19742 
   - orderId
19743 
   - warehouseId
19744 
  """
19745 
 
19746 
  thrift_spec = (
19747 
    None, # 0
19748 
    (1, TType.I64, 'orderId', None, None, ), # 1
19749 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19750 
  )
19751 
 
19752 
  def __init__(self, orderId=None, warehouseId=None,):
19753 
    self.orderId = orderId
19754 
    self.warehouseId = warehouseId
19755 
 
19756 
  def read(self, iprot):
19757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19759 
      return
19760 
    iprot.readStructBegin()
19761 
    while True:
19762 
      (fname, ftype, fid) = iprot.readFieldBegin()
19763 
      if ftype == TType.STOP:
19764 
        break
19765 
      if fid == 1:
19766 
        if ftype == TType.I64:
19767 
          self.orderId = iprot.readI64();
19768 
        else:
19769 
          iprot.skip(ftype)
19770 
      elif fid == 2:
19771 
        if ftype == TType.I64:
19772 
          self.warehouseId = iprot.readI64();
19773 
        else:
19774 
          iprot.skip(ftype)
19775 
      else:
19776 
        iprot.skip(ftype)
19777 
      iprot.readFieldEnd()
19778 
    iprot.readStructEnd()
19779 
 
19780 
  def write(self, oprot):
19781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19783 
      return
19784 
    oprot.writeStructBegin('shiftToWarehouse_args')
19785 
    if self.orderId is not None:
19786 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19787 
      oprot.writeI64(self.orderId)
19788 
      oprot.writeFieldEnd()
19789 
    if self.warehouseId is not None:
19790 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19791 
      oprot.writeI64(self.warehouseId)
19792 
      oprot.writeFieldEnd()
19793 
    oprot.writeFieldStop()
19794 
    oprot.writeStructEnd()
19795 
 
19796 
  def validate(self):
19797 
    return
19798 
 
19799 
 
19800 
  def __repr__(self):
19801 
    L = ['%s=%r' % (key, value)
19802 
      for key, value in self.__dict__.iteritems()]
19803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19804 
 
19805 
  def __eq__(self, other):
19806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19807 
 
19808 
  def __ne__(self, other):
19809 
    return not (self == other)
19810 
 
19811 
class shiftToWarehouse_result:
19812 
  """
19813 
  Attributes:
19814 
   - success
19815 
   - ex
19816 
  """
19817 
 
19818 
  thrift_spec = (
19819 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19821 
  )
19822 
 
19823 
  def __init__(self, success=None, ex=None,):
19824 
    self.success = success
19825 
    self.ex = ex
19826 
 
19827 
  def read(self, iprot):
19828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19830 
      return
19831 
    iprot.readStructBegin()
19832 
    while True:
19833 
      (fname, ftype, fid) = iprot.readFieldBegin()
19834 
      if ftype == TType.STOP:
19835 
        break
19836 
      if fid == 0:
19837 
        if ftype == TType.STRUCT:
19838 
          self.success = Order()
19839 
          self.success.read(iprot)
19840 
        else:
19841 
          iprot.skip(ftype)
19842 
      elif fid == 1:
19843 
        if ftype == TType.STRUCT:
19844 
          self.ex = TransactionServiceException()
19845 
          self.ex.read(iprot)
19846 
        else:
19847 
          iprot.skip(ftype)
19848 
      else:
19849 
        iprot.skip(ftype)
19850 
      iprot.readFieldEnd()
19851 
    iprot.readStructEnd()
19852 
 
19853 
  def write(self, oprot):
19854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19856 
      return
19857 
    oprot.writeStructBegin('shiftToWarehouse_result')
19858 
    if self.success is not None:
19859 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19860 
      self.success.write(oprot)
19861 
      oprot.writeFieldEnd()
19862 
    if self.ex is not None:
19863 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19864 
      self.ex.write(oprot)
19865 
      oprot.writeFieldEnd()
19866 
    oprot.writeFieldStop()
19867 
    oprot.writeStructEnd()
19868 
 
19869 
  def validate(self):
19870 
    return
19871 
 
19872 
 
19873 
  def __repr__(self):
19874 
    L = ['%s=%r' % (key, value)
19875 
      for key, value in self.__dict__.iteritems()]
19876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19877 
 
19878 
  def __eq__(self, other):
19879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19880 
 
19881 
  def __ne__(self, other):
19882 
    return not (self == other)
3553 chandransh 19883 
 
19884 
class addDelayReason_args:
19885 
  """
19886 
  Attributes:
19887 
   - orderId
19888 
   - delayReason
3986 chandransh 19889 
   - furtherDelay
4647 rajveer 19890 
   - delayReasonText
3553 chandransh 19891 
  """
19892 
 
19893 
  thrift_spec = (
19894 
    None, # 0
19895 
    (1, TType.I64, 'orderId', None, None, ), # 1
19896 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19897 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19898 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19899 
  )
19900 
 
4647 rajveer 19901 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19902 
    self.orderId = orderId
19903 
    self.delayReason = delayReason
3986 chandransh 19904 
    self.furtherDelay = furtherDelay
4647 rajveer 19905 
    self.delayReasonText = delayReasonText
3553 chandransh 19906 
 
19907 
  def read(self, iprot):
19908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19910 
      return
19911 
    iprot.readStructBegin()
19912 
    while True:
19913 
      (fname, ftype, fid) = iprot.readFieldBegin()
19914 
      if ftype == TType.STOP:
19915 
        break
19916 
      if fid == 1:
19917 
        if ftype == TType.I64:
19918 
          self.orderId = iprot.readI64();
19919 
        else:
19920 
          iprot.skip(ftype)
19921 
      elif fid == 2:
19922 
        if ftype == TType.I32:
19923 
          self.delayReason = iprot.readI32();
19924 
        else:
19925 
          iprot.skip(ftype)
3986 chandransh 19926 
      elif fid == 3:
19927 
        if ftype == TType.I64:
19928 
          self.furtherDelay = iprot.readI64();
19929 
        else:
19930 
          iprot.skip(ftype)
4647 rajveer 19931 
      elif fid == 4:
19932 
        if ftype == TType.STRING:
19933 
          self.delayReasonText = iprot.readString();
19934 
        else:
19935 
          iprot.skip(ftype)
3553 chandransh 19936 
      else:
19937 
        iprot.skip(ftype)
19938 
      iprot.readFieldEnd()
19939 
    iprot.readStructEnd()
19940 
 
19941 
  def write(self, oprot):
19942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19944 
      return
19945 
    oprot.writeStructBegin('addDelayReason_args')
19946 
    if self.orderId is not None:
19947 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19948 
      oprot.writeI64(self.orderId)
19949 
      oprot.writeFieldEnd()
19950 
    if self.delayReason is not None:
19951 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19952 
      oprot.writeI32(self.delayReason)
19953 
      oprot.writeFieldEnd()
3986 chandransh 19954 
    if self.furtherDelay is not None:
19955 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19956 
      oprot.writeI64(self.furtherDelay)
19957 
      oprot.writeFieldEnd()
4647 rajveer 19958 
    if self.delayReasonText is not None:
19959 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19960 
      oprot.writeString(self.delayReasonText)
19961 
      oprot.writeFieldEnd()
3553 chandransh 19962 
    oprot.writeFieldStop()
19963 
    oprot.writeStructEnd()
19964 
 
19965 
  def validate(self):
19966 
    return
19967 
 
19968 
 
19969 
  def __repr__(self):
19970 
    L = ['%s=%r' % (key, value)
19971 
      for key, value in self.__dict__.iteritems()]
19972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19973 
 
19974 
  def __eq__(self, other):
19975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19976 
 
19977 
  def __ne__(self, other):
19978 
    return not (self == other)
19979 
 
19980 
class addDelayReason_result:
19981 
  """
19982 
  Attributes:
19983 
   - success
19984 
   - ex
19985 
  """
19986 
 
19987 
  thrift_spec = (
19988 
    (0, TType.BOOL, 'success', None, None, ), # 0
19989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19990 
  )
19991 
 
19992 
  def __init__(self, success=None, ex=None,):
19993 
    self.success = success
19994 
    self.ex = ex
19995 
 
19996 
  def read(self, iprot):
19997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19999 
      return
20000 
    iprot.readStructBegin()
20001 
    while True:
20002 
      (fname, ftype, fid) = iprot.readFieldBegin()
20003 
      if ftype == TType.STOP:
20004 
        break
20005 
      if fid == 0:
20006 
        if ftype == TType.BOOL:
20007 
          self.success = iprot.readBool();
20008 
        else:
20009 
          iprot.skip(ftype)
20010 
      elif fid == 1:
20011 
        if ftype == TType.STRUCT:
20012 
          self.ex = TransactionServiceException()
20013 
          self.ex.read(iprot)
20014 
        else:
20015 
          iprot.skip(ftype)
20016 
      else:
20017 
        iprot.skip(ftype)
20018 
      iprot.readFieldEnd()
20019 
    iprot.readStructEnd()
20020 
 
20021 
  def write(self, oprot):
20022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20024 
      return
20025 
    oprot.writeStructBegin('addDelayReason_result')
20026 
    if self.success is not None:
20027 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20028 
      oprot.writeBool(self.success)
20029 
      oprot.writeFieldEnd()
20030 
    if self.ex is not None:
20031 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20032 
      self.ex.write(oprot)
20033 
      oprot.writeFieldEnd()
20034 
    oprot.writeFieldStop()
20035 
    oprot.writeStructEnd()
20036 
 
20037 
  def validate(self):
20038 
    return
20039 
 
20040 
 
20041 
  def __repr__(self):
20042 
    L = ['%s=%r' % (key, value)
20043 
      for key, value in self.__dict__.iteritems()]
20044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20045 
 
20046 
  def __eq__(self, other):
20047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20048 
 
20049 
  def __ne__(self, other):
20050 
    return not (self == other)
3956 chandransh 20051 
 
20052 
class reconcileCodCollection_args:
20053 
  """
20054 
  Attributes:
20055 
   - collectedAmountMap
20056 
   - xferBy
20057 
   - xferTxnId
20058 
   - xferDate
20059 
  """
20060 
 
20061 
  thrift_spec = (
20062 
    None, # 0
20063 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20064 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20065 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20066 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20067 
  )
20068 
 
20069 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20070 
    self.collectedAmountMap = collectedAmountMap
20071 
    self.xferBy = xferBy
20072 
    self.xferTxnId = xferTxnId
20073 
    self.xferDate = xferDate
20074 
 
20075 
  def read(self, iprot):
20076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20078 
      return
20079 
    iprot.readStructBegin()
20080 
    while True:
20081 
      (fname, ftype, fid) = iprot.readFieldBegin()
20082 
      if ftype == TType.STOP:
20083 
        break
20084 
      if fid == 1:
20085 
        if ftype == TType.MAP:
20086 
          self.collectedAmountMap = {}
6188 rajveer 20087 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20088 
          for _i457 in xrange(_size453):
20089 
            _key458 = iprot.readString();
20090 
            _val459 = iprot.readDouble();
20091 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20092 
          iprot.readMapEnd()
20093 
        else:
20094 
          iprot.skip(ftype)
20095 
      elif fid == 2:
20096 
        if ftype == TType.STRING:
20097 
          self.xferBy = iprot.readString();
20098 
        else:
20099 
          iprot.skip(ftype)
20100 
      elif fid == 3:
20101 
        if ftype == TType.STRING:
20102 
          self.xferTxnId = iprot.readString();
20103 
        else:
20104 
          iprot.skip(ftype)
20105 
      elif fid == 4:
20106 
        if ftype == TType.I64:
20107 
          self.xferDate = iprot.readI64();
20108 
        else:
20109 
          iprot.skip(ftype)
20110 
      else:
20111 
        iprot.skip(ftype)
20112 
      iprot.readFieldEnd()
20113 
    iprot.readStructEnd()
20114 
 
20115 
  def write(self, oprot):
20116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20118 
      return
20119 
    oprot.writeStructBegin('reconcileCodCollection_args')
20120 
    if self.collectedAmountMap is not None:
20121 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20122 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20123 
      for kiter460,viter461 in self.collectedAmountMap.items():
20124 
        oprot.writeString(kiter460)
20125 
        oprot.writeDouble(viter461)
3956 chandransh 20126 
      oprot.writeMapEnd()
20127 
      oprot.writeFieldEnd()
20128 
    if self.xferBy is not None:
20129 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20130 
      oprot.writeString(self.xferBy)
20131 
      oprot.writeFieldEnd()
20132 
    if self.xferTxnId is not None:
20133 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20134 
      oprot.writeString(self.xferTxnId)
20135 
      oprot.writeFieldEnd()
20136 
    if self.xferDate is not None:
20137 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20138 
      oprot.writeI64(self.xferDate)
20139 
      oprot.writeFieldEnd()
20140 
    oprot.writeFieldStop()
20141 
    oprot.writeStructEnd()
20142 
 
20143 
  def validate(self):
20144 
    return
20145 
 
20146 
 
20147 
  def __repr__(self):
20148 
    L = ['%s=%r' % (key, value)
20149 
      for key, value in self.__dict__.iteritems()]
20150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20151 
 
20152 
  def __eq__(self, other):
20153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20154 
 
20155 
  def __ne__(self, other):
20156 
    return not (self == other)
20157 
 
20158 
class reconcileCodCollection_result:
20159 
  """
20160 
  Attributes:
20161 
   - success
20162 
   - ex
20163 
  """
20164 
 
20165 
  thrift_spec = (
20166 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20168 
  )
20169 
 
20170 
  def __init__(self, success=None, ex=None,):
20171 
    self.success = success
20172 
    self.ex = ex
20173 
 
20174 
  def read(self, iprot):
20175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20177 
      return
20178 
    iprot.readStructBegin()
20179 
    while True:
20180 
      (fname, ftype, fid) = iprot.readFieldBegin()
20181 
      if ftype == TType.STOP:
20182 
        break
20183 
      if fid == 0:
20184 
        if ftype == TType.MAP:
20185 
          self.success = {}
6188 rajveer 20186 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20187 
          for _i466 in xrange(_size462):
20188 
            _key467 = iprot.readString();
20189 
            _val468 = iprot.readString();
20190 
            self.success[_key467] = _val468
3956 chandransh 20191 
          iprot.readMapEnd()
20192 
        else:
20193 
          iprot.skip(ftype)
20194 
      elif fid == 1:
20195 
        if ftype == TType.STRUCT:
20196 
          self.ex = TransactionServiceException()
20197 
          self.ex.read(iprot)
20198 
        else:
20199 
          iprot.skip(ftype)
20200 
      else:
20201 
        iprot.skip(ftype)
20202 
      iprot.readFieldEnd()
20203 
    iprot.readStructEnd()
20204 
 
20205 
  def write(self, oprot):
20206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20208 
      return
20209 
    oprot.writeStructBegin('reconcileCodCollection_result')
20210 
    if self.success is not None:
20211 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20212 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20213 
      for kiter469,viter470 in self.success.items():
20214 
        oprot.writeString(kiter469)
20215 
        oprot.writeString(viter470)
3956 chandransh 20216 
      oprot.writeMapEnd()
20217 
      oprot.writeFieldEnd()
20218 
    if self.ex is not None:
20219 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20220 
      self.ex.write(oprot)
20221 
      oprot.writeFieldEnd()
20222 
    oprot.writeFieldStop()
20223 
    oprot.writeStructEnd()
20224 
 
20225 
  def validate(self):
20226 
    return
20227 
 
20228 
 
20229 
  def __repr__(self):
20230 
    L = ['%s=%r' % (key, value)
20231 
      for key, value in self.__dict__.iteritems()]
20232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20233 
 
20234 
  def __eq__(self, other):
20235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20236 
 
20237 
  def __ne__(self, other):
20238 
    return not (self == other)
4008 mandeep.dh 20239 
 
20240 
class getTransactionsRequiringExtraProcessing_args:
20241 
  """
20242 
  Attributes:
20243 
   - category
20244 
  """
20245 
 
20246 
  thrift_spec = (
20247 
    None, # 0
20248 
    (1, TType.I32, 'category', None, None, ), # 1
20249 
  )
20250 
 
20251 
  def __init__(self, category=None,):
20252 
    self.category = category
20253 
 
20254 
  def read(self, iprot):
20255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20257 
      return
20258 
    iprot.readStructBegin()
20259 
    while True:
20260 
      (fname, ftype, fid) = iprot.readFieldBegin()
20261 
      if ftype == TType.STOP:
20262 
        break
20263 
      if fid == 1:
20264 
        if ftype == TType.I32:
20265 
          self.category = iprot.readI32();
20266 
        else:
20267 
          iprot.skip(ftype)
20268 
      else:
20269 
        iprot.skip(ftype)
20270 
      iprot.readFieldEnd()
20271 
    iprot.readStructEnd()
20272 
 
20273 
  def write(self, oprot):
20274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20276 
      return
20277 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20278 
    if self.category is not None:
20279 
      oprot.writeFieldBegin('category', TType.I32, 1)
20280 
      oprot.writeI32(self.category)
20281 
      oprot.writeFieldEnd()
20282 
    oprot.writeFieldStop()
20283 
    oprot.writeStructEnd()
20284 
 
20285 
  def validate(self):
20286 
    return
20287 
 
20288 
 
20289 
  def __repr__(self):
20290 
    L = ['%s=%r' % (key, value)
20291 
      for key, value in self.__dict__.iteritems()]
20292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20293 
 
20294 
  def __eq__(self, other):
20295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20296 
 
20297 
  def __ne__(self, other):
20298 
    return not (self == other)
20299 
 
20300 
class getTransactionsRequiringExtraProcessing_result:
20301 
  """
20302 
  Attributes:
20303 
   - success
20304 
  """
20305 
 
20306 
  thrift_spec = (
20307 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20308 
  )
20309 
 
20310 
  def __init__(self, success=None,):
20311 
    self.success = success
20312 
 
20313 
  def read(self, iprot):
20314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20316 
      return
20317 
    iprot.readStructBegin()
20318 
    while True:
20319 
      (fname, ftype, fid) = iprot.readFieldBegin()
20320 
      if ftype == TType.STOP:
20321 
        break
20322 
      if fid == 0:
20323 
        if ftype == TType.LIST:
20324 
          self.success = []
6188 rajveer 20325 
          (_etype474, _size471) = iprot.readListBegin()
20326 
          for _i475 in xrange(_size471):
20327 
            _elem476 = iprot.readI64();
20328 
            self.success.append(_elem476)
4008 mandeep.dh 20329 
          iprot.readListEnd()
20330 
        else:
20331 
          iprot.skip(ftype)
20332 
      else:
20333 
        iprot.skip(ftype)
20334 
      iprot.readFieldEnd()
20335 
    iprot.readStructEnd()
20336 
 
20337 
  def write(self, oprot):
20338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20340 
      return
20341 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20342 
    if self.success is not None:
20343 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20344 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20345 
      for iter477 in self.success:
20346 
        oprot.writeI64(iter477)
4008 mandeep.dh 20347 
      oprot.writeListEnd()
20348 
      oprot.writeFieldEnd()
20349 
    oprot.writeFieldStop()
20350 
    oprot.writeStructEnd()
20351 
 
20352 
  def validate(self):
20353 
    return
20354 
 
20355 
 
20356 
  def __repr__(self):
20357 
    L = ['%s=%r' % (key, value)
20358 
      for key, value in self.__dict__.iteritems()]
20359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20360 
 
20361 
  def __eq__(self, other):
20362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20363 
 
20364 
  def __ne__(self, other):
20365 
    return not (self == other)
20366 
 
20367 
class markTransactionAsProcessed_args:
20368 
  """
20369 
  Attributes:
20370 
   - transactionId
20371 
   - category
20372 
  """
20373 
 
20374 
  thrift_spec = (
20375 
    None, # 0
20376 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20377 
    (2, TType.I32, 'category', None, None, ), # 2
20378 
  )
20379 
 
20380 
  def __init__(self, transactionId=None, category=None,):
20381 
    self.transactionId = transactionId
20382 
    self.category = category
20383 
 
20384 
  def read(self, iprot):
20385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20387 
      return
20388 
    iprot.readStructBegin()
20389 
    while True:
20390 
      (fname, ftype, fid) = iprot.readFieldBegin()
20391 
      if ftype == TType.STOP:
20392 
        break
20393 
      if fid == 1:
20394 
        if ftype == TType.I64:
20395 
          self.transactionId = iprot.readI64();
20396 
        else:
20397 
          iprot.skip(ftype)
20398 
      elif fid == 2:
20399 
        if ftype == TType.I32:
20400 
          self.category = iprot.readI32();
20401 
        else:
20402 
          iprot.skip(ftype)
20403 
      else:
20404 
        iprot.skip(ftype)
20405 
      iprot.readFieldEnd()
20406 
    iprot.readStructEnd()
20407 
 
20408 
  def write(self, oprot):
20409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20411 
      return
20412 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20413 
    if self.transactionId is not None:
20414 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20415 
      oprot.writeI64(self.transactionId)
20416 
      oprot.writeFieldEnd()
20417 
    if self.category is not None:
20418 
      oprot.writeFieldBegin('category', TType.I32, 2)
20419 
      oprot.writeI32(self.category)
20420 
      oprot.writeFieldEnd()
20421 
    oprot.writeFieldStop()
20422 
    oprot.writeStructEnd()
20423 
 
20424 
  def validate(self):
20425 
    return
20426 
 
20427 
 
20428 
  def __repr__(self):
20429 
    L = ['%s=%r' % (key, value)
20430 
      for key, value in self.__dict__.iteritems()]
20431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20432 
 
20433 
  def __eq__(self, other):
20434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20435 
 
20436 
  def __ne__(self, other):
20437 
    return not (self == other)
20438 
 
20439 
class markTransactionAsProcessed_result:
20440 
 
20441 
  thrift_spec = (
20442 
  )
20443 
 
20444 
  def read(self, iprot):
20445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20447 
      return
20448 
    iprot.readStructBegin()
20449 
    while True:
20450 
      (fname, ftype, fid) = iprot.readFieldBegin()
20451 
      if ftype == TType.STOP:
20452 
        break
20453 
      else:
20454 
        iprot.skip(ftype)
20455 
      iprot.readFieldEnd()
20456 
    iprot.readStructEnd()
20457 
 
20458 
  def write(self, oprot):
20459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20461 
      return
20462 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20463 
    oprot.writeFieldStop()
20464 
    oprot.writeStructEnd()
20465 
 
20466 
  def validate(self):
20467 
    return
20468 
 
20469 
 
20470 
  def __repr__(self):
20471 
    L = ['%s=%r' % (key, value)
20472 
      for key, value in self.__dict__.iteritems()]
20473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20474 
 
20475 
  def __eq__(self, other):
20476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20477 
 
20478 
  def __ne__(self, other):
20479 
    return not (self == other)
4018 chandransh 20480 
 
20481 
class getItemWiseRiskyOrdersCount_args:
20482 
 
20483 
  thrift_spec = (
20484 
  )
20485 
 
20486 
  def read(self, iprot):
20487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20489 
      return
20490 
    iprot.readStructBegin()
20491 
    while True:
20492 
      (fname, ftype, fid) = iprot.readFieldBegin()
20493 
      if ftype == TType.STOP:
20494 
        break
20495 
      else:
20496 
        iprot.skip(ftype)
20497 
      iprot.readFieldEnd()
20498 
    iprot.readStructEnd()
20499 
 
20500 
  def write(self, oprot):
20501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20503 
      return
20504 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20505 
    oprot.writeFieldStop()
20506 
    oprot.writeStructEnd()
20507 
 
20508 
  def validate(self):
20509 
    return
20510 
 
20511 
 
20512 
  def __repr__(self):
20513 
    L = ['%s=%r' % (key, value)
20514 
      for key, value in self.__dict__.iteritems()]
20515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20516 
 
20517 
  def __eq__(self, other):
20518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20519 
 
20520 
  def __ne__(self, other):
20521 
    return not (self == other)
20522 
 
20523 
class getItemWiseRiskyOrdersCount_result:
20524 
  """
20525 
  Attributes:
20526 
   - success
20527 
  """
20528 
 
20529 
  thrift_spec = (
20530 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20531 
  )
20532 
 
20533 
  def __init__(self, success=None,):
20534 
    self.success = success
20535 
 
20536 
  def read(self, iprot):
20537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20539 
      return
20540 
    iprot.readStructBegin()
20541 
    while True:
20542 
      (fname, ftype, fid) = iprot.readFieldBegin()
20543 
      if ftype == TType.STOP:
20544 
        break
20545 
      if fid == 0:
20546 
        if ftype == TType.MAP:
20547 
          self.success = {}
6188 rajveer 20548 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20549 
          for _i482 in xrange(_size478):
20550 
            _key483 = iprot.readI64();
20551 
            _val484 = iprot.readI64();
20552 
            self.success[_key483] = _val484
4018 chandransh 20553 
          iprot.readMapEnd()
20554 
        else:
20555 
          iprot.skip(ftype)
20556 
      else:
20557 
        iprot.skip(ftype)
20558 
      iprot.readFieldEnd()
20559 
    iprot.readStructEnd()
20560 
 
20561 
  def write(self, oprot):
20562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20564 
      return
20565 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20566 
    if self.success is not None:
20567 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20568 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20569 
      for kiter485,viter486 in self.success.items():
20570 
        oprot.writeI64(kiter485)
20571 
        oprot.writeI64(viter486)
4018 chandransh 20572 
      oprot.writeMapEnd()
20573 
      oprot.writeFieldEnd()
20574 
    oprot.writeFieldStop()
20575 
    oprot.writeStructEnd()
20576 
 
20577 
  def validate(self):
20578 
    return
20579 
 
20580 
 
20581 
  def __repr__(self):
20582 
    L = ['%s=%r' % (key, value)
20583 
      for key, value in self.__dict__.iteritems()]
20584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20585 
 
20586 
  def __eq__(self, other):
20587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20588 
 
20589 
  def __ne__(self, other):
20590 
    return not (self == other)
4247 rajveer 20591 
 
4295 varun.gupt 20592 
class getOrdersForItemIds_args:
20593 
  """
20594 
  Attributes:
20595 
   - itemIds
20596 
  """
20597 
 
20598 
  thrift_spec = (
20599 
    None, # 0
20600 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20601 
  )
20602 
 
20603 
  def __init__(self, itemIds=None,):
20604 
    self.itemIds = itemIds
20605 
 
20606 
  def read(self, iprot):
20607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20609 
      return
20610 
    iprot.readStructBegin()
20611 
    while True:
20612 
      (fname, ftype, fid) = iprot.readFieldBegin()
20613 
      if ftype == TType.STOP:
20614 
        break
20615 
      if fid == 1:
20616 
        if ftype == TType.LIST:
20617 
          self.itemIds = []
6188 rajveer 20618 
          (_etype490, _size487) = iprot.readListBegin()
20619 
          for _i491 in xrange(_size487):
20620 
            _elem492 = iprot.readI64();
20621 
            self.itemIds.append(_elem492)
4295 varun.gupt 20622 
          iprot.readListEnd()
20623 
        else:
20624 
          iprot.skip(ftype)
20625 
      else:
20626 
        iprot.skip(ftype)
20627 
      iprot.readFieldEnd()
20628 
    iprot.readStructEnd()
20629 
 
20630 
  def write(self, oprot):
20631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20633 
      return
20634 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20635 
    if self.itemIds is not None:
20636 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20637 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20638 
      for iter493 in self.itemIds:
20639 
        oprot.writeI64(iter493)
4295 varun.gupt 20640 
      oprot.writeListEnd()
20641 
      oprot.writeFieldEnd()
20642 
    oprot.writeFieldStop()
20643 
    oprot.writeStructEnd()
20644 
 
20645 
  def validate(self):
20646 
    return
20647 
 
20648 
 
20649 
  def __repr__(self):
20650 
    L = ['%s=%r' % (key, value)
20651 
      for key, value in self.__dict__.iteritems()]
20652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20653 
 
20654 
  def __eq__(self, other):
20655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20656 
 
20657 
  def __ne__(self, other):
20658 
    return not (self == other)
20659 
 
20660 
class getOrdersForItemIds_result:
20661 
  """
20662 
  Attributes:
20663 
   - success
20664 
  """
20665 
 
20666 
  thrift_spec = (
20667 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20668 
  )
20669 
 
20670 
  def __init__(self, success=None,):
20671 
    self.success = success
20672 
 
20673 
  def read(self, iprot):
20674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20676 
      return
20677 
    iprot.readStructBegin()
20678 
    while True:
20679 
      (fname, ftype, fid) = iprot.readFieldBegin()
20680 
      if ftype == TType.STOP:
20681 
        break
20682 
      if fid == 0:
20683 
        if ftype == TType.LIST:
20684 
          self.success = []
6188 rajveer 20685 
          (_etype497, _size494) = iprot.readListBegin()
20686 
          for _i498 in xrange(_size494):
20687 
            _elem499 = Order()
20688 
            _elem499.read(iprot)
20689 
            self.success.append(_elem499)
4295 varun.gupt 20690 
          iprot.readListEnd()
20691 
        else:
20692 
          iprot.skip(ftype)
20693 
      else:
20694 
        iprot.skip(ftype)
20695 
      iprot.readFieldEnd()
20696 
    iprot.readStructEnd()
20697 
 
20698 
  def write(self, oprot):
20699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20701 
      return
20702 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20703 
    if self.success is not None:
20704 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20705 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20706 
      for iter500 in self.success:
20707 
        iter500.write(oprot)
4295 varun.gupt 20708 
      oprot.writeListEnd()
20709 
      oprot.writeFieldEnd()
20710 
    oprot.writeFieldStop()
20711 
    oprot.writeStructEnd()
20712 
 
20713 
  def validate(self):
20714 
    return
20715 
 
20716 
 
20717 
  def __repr__(self):
20718 
    L = ['%s=%r' % (key, value)
20719 
      for key, value in self.__dict__.iteritems()]
20720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20721 
 
20722 
  def __eq__(self, other):
20723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20724 
 
20725 
  def __ne__(self, other):
20726 
    return not (self == other)
20727 
 
4247 rajveer 20728 
class markOrderCancellationRequestReceived_args:
20729 
  """
20730 
  Attributes:
20731 
   - orderId
20732 
  """
20733 
 
20734 
  thrift_spec = (
20735 
    None, # 0
20736 
    (1, TType.I64, 'orderId', None, None, ), # 1
20737 
  )
20738 
 
20739 
  def __init__(self, orderId=None,):
20740 
    self.orderId = orderId
20741 
 
20742 
  def read(self, iprot):
20743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20745 
      return
20746 
    iprot.readStructBegin()
20747 
    while True:
20748 
      (fname, ftype, fid) = iprot.readFieldBegin()
20749 
      if ftype == TType.STOP:
20750 
        break
20751 
      if fid == 1:
20752 
        if ftype == TType.I64:
20753 
          self.orderId = iprot.readI64();
20754 
        else:
20755 
          iprot.skip(ftype)
20756 
      else:
20757 
        iprot.skip(ftype)
20758 
      iprot.readFieldEnd()
20759 
    iprot.readStructEnd()
20760 
 
20761 
  def write(self, oprot):
20762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20764 
      return
20765 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20766 
    if self.orderId is not None:
20767 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20768 
      oprot.writeI64(self.orderId)
20769 
      oprot.writeFieldEnd()
20770 
    oprot.writeFieldStop()
20771 
    oprot.writeStructEnd()
20772 
 
20773 
  def validate(self):
20774 
    return
20775 
 
20776 
 
20777 
  def __repr__(self):
20778 
    L = ['%s=%r' % (key, value)
20779 
      for key, value in self.__dict__.iteritems()]
20780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20781 
 
20782 
  def __eq__(self, other):
20783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20784 
 
20785 
  def __ne__(self, other):
20786 
    return not (self == other)
20787 
 
20788 
class markOrderCancellationRequestReceived_result:
20789 
  """
20790 
  Attributes:
20791 
   - ex
20792 
  """
20793 
 
20794 
  thrift_spec = (
20795 
    None, # 0
20796 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20797 
  )
20798 
 
20799 
  def __init__(self, ex=None,):
20800 
    self.ex = ex
20801 
 
20802 
  def read(self, iprot):
20803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20805 
      return
20806 
    iprot.readStructBegin()
20807 
    while True:
20808 
      (fname, ftype, fid) = iprot.readFieldBegin()
20809 
      if ftype == TType.STOP:
20810 
        break
20811 
      if fid == 1:
20812 
        if ftype == TType.STRUCT:
20813 
          self.ex = TransactionServiceException()
20814 
          self.ex.read(iprot)
20815 
        else:
20816 
          iprot.skip(ftype)
20817 
      else:
20818 
        iprot.skip(ftype)
20819 
      iprot.readFieldEnd()
20820 
    iprot.readStructEnd()
20821 
 
20822 
  def write(self, oprot):
20823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20825 
      return
20826 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20827 
    if self.ex is not None:
20828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20829 
      self.ex.write(oprot)
20830 
      oprot.writeFieldEnd()
20831 
    oprot.writeFieldStop()
20832 
    oprot.writeStructEnd()
20833 
 
20834 
  def validate(self):
20835 
    return
20836 
 
20837 
 
20838 
  def __repr__(self):
20839 
    L = ['%s=%r' % (key, value)
20840 
      for key, value in self.__dict__.iteritems()]
20841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20842 
 
20843 
  def __eq__(self, other):
20844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20845 
 
20846 
  def __ne__(self, other):
20847 
    return not (self == other)
20848 
 
20849 
class markOrderCancellationRequestConfirmed_args:
20850 
  """
20851 
  Attributes:
20852 
   - orderId
20853 
  """
20854 
 
20855 
  thrift_spec = (
20856 
    None, # 0
20857 
    (1, TType.I64, 'orderId', None, None, ), # 1
20858 
  )
20859 
 
20860 
  def __init__(self, orderId=None,):
20861 
    self.orderId = orderId
20862 
 
20863 
  def read(self, iprot):
20864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20866 
      return
20867 
    iprot.readStructBegin()
20868 
    while True:
20869 
      (fname, ftype, fid) = iprot.readFieldBegin()
20870 
      if ftype == TType.STOP:
20871 
        break
20872 
      if fid == 1:
20873 
        if ftype == TType.I64:
20874 
          self.orderId = iprot.readI64();
20875 
        else:
20876 
          iprot.skip(ftype)
20877 
      else:
20878 
        iprot.skip(ftype)
20879 
      iprot.readFieldEnd()
20880 
    iprot.readStructEnd()
20881 
 
20882 
  def write(self, oprot):
20883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20885 
      return
20886 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20887 
    if self.orderId is not None:
20888 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20889 
      oprot.writeI64(self.orderId)
20890 
      oprot.writeFieldEnd()
20891 
    oprot.writeFieldStop()
20892 
    oprot.writeStructEnd()
20893 
 
20894 
  def validate(self):
20895 
    return
20896 
 
20897 
 
20898 
  def __repr__(self):
20899 
    L = ['%s=%r' % (key, value)
20900 
      for key, value in self.__dict__.iteritems()]
20901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20902 
 
20903 
  def __eq__(self, other):
20904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20905 
 
20906 
  def __ne__(self, other):
20907 
    return not (self == other)
20908 
 
20909 
class markOrderCancellationRequestConfirmed_result:
20910 
  """
20911 
  Attributes:
20912 
   - ex
20913 
  """
20914 
 
20915 
  thrift_spec = (
20916 
    None, # 0
20917 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20918 
  )
20919 
 
20920 
  def __init__(self, ex=None,):
20921 
    self.ex = ex
20922 
 
20923 
  def read(self, iprot):
20924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20926 
      return
20927 
    iprot.readStructBegin()
20928 
    while True:
20929 
      (fname, ftype, fid) = iprot.readFieldBegin()
20930 
      if ftype == TType.STOP:
20931 
        break
20932 
      if fid == 1:
20933 
        if ftype == TType.STRUCT:
20934 
          self.ex = TransactionServiceException()
20935 
          self.ex.read(iprot)
20936 
        else:
20937 
          iprot.skip(ftype)
20938 
      else:
20939 
        iprot.skip(ftype)
20940 
      iprot.readFieldEnd()
20941 
    iprot.readStructEnd()
20942 
 
20943 
  def write(self, oprot):
20944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20946 
      return
20947 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20948 
    if self.ex is not None:
20949 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20950 
      self.ex.write(oprot)
20951 
      oprot.writeFieldEnd()
20952 
    oprot.writeFieldStop()
20953 
    oprot.writeStructEnd()
20954 
 
20955 
  def validate(self):
20956 
    return
20957 
 
20958 
 
20959 
  def __repr__(self):
20960 
    L = ['%s=%r' % (key, value)
20961 
      for key, value in self.__dict__.iteritems()]
20962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20963 
 
20964 
  def __eq__(self, other):
20965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20966 
 
20967 
  def __ne__(self, other):
20968 
    return not (self == other)
20969 
 
20970 
class markOrderCancellationRequestDenied_args:
20971 
  """
20972 
  Attributes:
20973 
   - orderId
20974 
  """
20975 
 
20976 
  thrift_spec = (
20977 
    None, # 0
20978 
    (1, TType.I64, 'orderId', None, None, ), # 1
20979 
  )
20980 
 
20981 
  def __init__(self, orderId=None,):
20982 
    self.orderId = orderId
20983 
 
20984 
  def read(self, iprot):
20985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20987 
      return
20988 
    iprot.readStructBegin()
20989 
    while True:
20990 
      (fname, ftype, fid) = iprot.readFieldBegin()
20991 
      if ftype == TType.STOP:
20992 
        break
20993 
      if fid == 1:
20994 
        if ftype == TType.I64:
20995 
          self.orderId = iprot.readI64();
20996 
        else:
20997 
          iprot.skip(ftype)
20998 
      else:
20999 
        iprot.skip(ftype)
21000 
      iprot.readFieldEnd()
21001 
    iprot.readStructEnd()
21002 
 
21003 
  def write(self, oprot):
21004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21006 
      return
21007 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21008 
    if self.orderId is not None:
21009 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21010 
      oprot.writeI64(self.orderId)
21011 
      oprot.writeFieldEnd()
21012 
    oprot.writeFieldStop()
21013 
    oprot.writeStructEnd()
21014 
 
21015 
  def validate(self):
21016 
    return
21017 
 
21018 
 
21019 
  def __repr__(self):
21020 
    L = ['%s=%r' % (key, value)
21021 
      for key, value in self.__dict__.iteritems()]
21022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21023 
 
21024 
  def __eq__(self, other):
21025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21026 
 
21027 
  def __ne__(self, other):
21028 
    return not (self == other)
21029 
 
21030 
class markOrderCancellationRequestDenied_result:
21031 
  """
21032 
  Attributes:
21033 
   - ex
21034 
  """
21035 
 
21036 
  thrift_spec = (
21037 
    None, # 0
21038 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21039 
  )
21040 
 
21041 
  def __init__(self, ex=None,):
21042 
    self.ex = ex
21043 
 
21044 
  def read(self, iprot):
21045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21047 
      return
21048 
    iprot.readStructBegin()
21049 
    while True:
21050 
      (fname, ftype, fid) = iprot.readFieldBegin()
21051 
      if ftype == TType.STOP:
21052 
        break
21053 
      if fid == 1:
21054 
        if ftype == TType.STRUCT:
21055 
          self.ex = TransactionServiceException()
21056 
          self.ex.read(iprot)
21057 
        else:
21058 
          iprot.skip(ftype)
21059 
      else:
21060 
        iprot.skip(ftype)
21061 
      iprot.readFieldEnd()
21062 
    iprot.readStructEnd()
21063 
 
21064 
  def write(self, oprot):
21065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21067 
      return
21068 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21069 
    if self.ex is not None:
21070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21071 
      self.ex.write(oprot)
21072 
      oprot.writeFieldEnd()
21073 
    oprot.writeFieldStop()
21074 
    oprot.writeStructEnd()
21075 
 
21076 
  def validate(self):
21077 
    return
21078 
 
21079 
 
21080 
  def __repr__(self):
21081 
    L = ['%s=%r' % (key, value)
21082 
      for key, value in self.__dict__.iteritems()]
21083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21084 
 
21085 
  def __eq__(self, other):
21086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21087 
 
21088 
  def __ne__(self, other):
21089 
    return not (self == other)
21090 
 
4258 rajveer 21091 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21092 
  """
21093 
  Attributes:
4258 rajveer 21094 
   - transactionId
4247 rajveer 21095 
  """
21096 
 
21097 
  thrift_spec = (
21098 
    None, # 0
4258 rajveer 21099 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21100 
  )
21101 
 
4258 rajveer 21102 
  def __init__(self, transactionId=None,):
21103 
    self.transactionId = transactionId
4247 rajveer 21104 
 
21105 
  def read(self, iprot):
21106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21108 
      return
21109 
    iprot.readStructBegin()
21110 
    while True:
21111 
      (fname, ftype, fid) = iprot.readFieldBegin()
21112 
      if ftype == TType.STOP:
21113 
        break
21114 
      if fid == 1:
21115 
        if ftype == TType.I64:
4258 rajveer 21116 
          self.transactionId = iprot.readI64();
4247 rajveer 21117 
        else:
21118 
          iprot.skip(ftype)
21119 
      else:
21120 
        iprot.skip(ftype)
21121 
      iprot.readFieldEnd()
21122 
    iprot.readStructEnd()
21123 
 
21124 
  def write(self, oprot):
21125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21127 
      return
4258 rajveer 21128 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21129 
    if self.transactionId is not None:
21130 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21131 
      oprot.writeI64(self.transactionId)
4247 rajveer 21132 
      oprot.writeFieldEnd()
21133 
    oprot.writeFieldStop()
21134 
    oprot.writeStructEnd()
21135 
 
21136 
  def validate(self):
21137 
    return
21138 
 
21139 
 
21140 
  def __repr__(self):
21141 
    L = ['%s=%r' % (key, value)
21142 
      for key, value in self.__dict__.iteritems()]
21143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21144 
 
21145 
  def __eq__(self, other):
21146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21147 
 
21148 
  def __ne__(self, other):
21149 
    return not (self == other)
21150 
 
4258 rajveer 21151 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21152 
  """
21153 
  Attributes:
21154 
   - ex
21155 
  """
21156 
 
21157 
  thrift_spec = (
21158 
    None, # 0
21159 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21160 
  )
21161 
 
21162 
  def __init__(self, ex=None,):
21163 
    self.ex = ex
21164 
 
21165 
  def read(self, iprot):
21166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21168 
      return
21169 
    iprot.readStructBegin()
21170 
    while True:
21171 
      (fname, ftype, fid) = iprot.readFieldBegin()
21172 
      if ftype == TType.STOP:
21173 
        break
21174 
      if fid == 1:
21175 
        if ftype == TType.STRUCT:
21176 
          self.ex = TransactionServiceException()
21177 
          self.ex.read(iprot)
21178 
        else:
21179 
          iprot.skip(ftype)
21180 
      else:
21181 
        iprot.skip(ftype)
21182 
      iprot.readFieldEnd()
21183 
    iprot.readStructEnd()
21184 
 
21185 
  def write(self, oprot):
21186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21188 
      return
4258 rajveer 21189 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21190 
    if self.ex is not None:
21191 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21192 
      self.ex.write(oprot)
21193 
      oprot.writeFieldEnd()
21194 
    oprot.writeFieldStop()
21195 
    oprot.writeStructEnd()
21196 
 
21197 
  def validate(self):
21198 
    return
21199 
 
21200 
 
21201 
  def __repr__(self):
21202 
    L = ['%s=%r' % (key, value)
21203 
      for key, value in self.__dict__.iteritems()]
21204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21205 
 
21206 
  def __eq__(self, other):
21207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21208 
 
21209 
  def __ne__(self, other):
21210 
    return not (self == other)
4259 anupam.sin 21211 
 
21212 
class refundTransaction_args:
21213 
  """
21214 
  Attributes:
21215 
   - transactionId
21216 
   - refundedBy
21217 
   - reason
21218 
  """
21219 
 
21220 
  thrift_spec = (
21221 
    None, # 0
21222 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21223 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21224 
    (3, TType.STRING, 'reason', None, None, ), # 3
21225 
  )
21226 
 
21227 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21228 
    self.transactionId = transactionId
21229 
    self.refundedBy = refundedBy
21230 
    self.reason = reason
21231 
 
21232 
  def read(self, iprot):
21233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21235 
      return
21236 
    iprot.readStructBegin()
21237 
    while True:
21238 
      (fname, ftype, fid) = iprot.readFieldBegin()
21239 
      if ftype == TType.STOP:
21240 
        break
21241 
      if fid == 1:
21242 
        if ftype == TType.I64:
21243 
          self.transactionId = iprot.readI64();
21244 
        else:
21245 
          iprot.skip(ftype)
21246 
      elif fid == 2:
21247 
        if ftype == TType.STRING:
21248 
          self.refundedBy = iprot.readString();
21249 
        else:
21250 
          iprot.skip(ftype)
21251 
      elif fid == 3:
21252 
        if ftype == TType.STRING:
21253 
          self.reason = iprot.readString();
21254 
        else:
21255 
          iprot.skip(ftype)
21256 
      else:
21257 
        iprot.skip(ftype)
21258 
      iprot.readFieldEnd()
21259 
    iprot.readStructEnd()
21260 
 
21261 
  def write(self, oprot):
21262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21264 
      return
21265 
    oprot.writeStructBegin('refundTransaction_args')
21266 
    if self.transactionId is not None:
21267 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21268 
      oprot.writeI64(self.transactionId)
21269 
      oprot.writeFieldEnd()
21270 
    if self.refundedBy is not None:
21271 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21272 
      oprot.writeString(self.refundedBy)
21273 
      oprot.writeFieldEnd()
21274 
    if self.reason is not None:
21275 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21276 
      oprot.writeString(self.reason)
21277 
      oprot.writeFieldEnd()
21278 
    oprot.writeFieldStop()
21279 
    oprot.writeStructEnd()
21280 
 
21281 
  def validate(self):
21282 
    return
21283 
 
21284 
 
21285 
  def __repr__(self):
21286 
    L = ['%s=%r' % (key, value)
21287 
      for key, value in self.__dict__.iteritems()]
21288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21289 
 
21290 
  def __eq__(self, other):
21291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21292 
 
21293 
  def __ne__(self, other):
21294 
    return not (self == other)
21295 
 
21296 
class refundTransaction_result:
21297 
  """
21298 
  Attributes:
21299 
   - ex
21300 
  """
21301 
 
21302 
  thrift_spec = (
21303 
    None, # 0
21304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21305 
  )
21306 
 
21307 
  def __init__(self, ex=None,):
21308 
    self.ex = ex
21309 
 
21310 
  def read(self, iprot):
21311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21313 
      return
21314 
    iprot.readStructBegin()
21315 
    while True:
21316 
      (fname, ftype, fid) = iprot.readFieldBegin()
21317 
      if ftype == TType.STOP:
21318 
        break
21319 
      if fid == 1:
21320 
        if ftype == TType.STRUCT:
21321 
          self.ex = TransactionServiceException()
21322 
          self.ex.read(iprot)
21323 
        else:
21324 
          iprot.skip(ftype)
21325 
      else:
21326 
        iprot.skip(ftype)
21327 
      iprot.readFieldEnd()
21328 
    iprot.readStructEnd()
21329 
 
21330 
  def write(self, oprot):
21331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21333 
      return
21334 
    oprot.writeStructBegin('refundTransaction_result')
21335 
    if self.ex is not None:
21336 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21337 
      self.ex.write(oprot)
21338 
      oprot.writeFieldEnd()
21339 
    oprot.writeFieldStop()
21340 
    oprot.writeStructEnd()
21341 
 
21342 
  def validate(self):
21343 
    return
21344 
 
21345 
 
21346 
  def __repr__(self):
21347 
    L = ['%s=%r' % (key, value)
21348 
      for key, value in self.__dict__.iteritems()]
21349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21350 
 
21351 
  def __eq__(self, other):
21352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21353 
 
21354 
  def __ne__(self, other):
21355 
    return not (self == other)
4285 rajveer 21356 
 
4324 mandeep.dh 21357 
class updateShipmentAddress_args:
21358 
  """
21359 
  Attributes:
21360 
   - orderId
21361 
   - addressId
21362 
  """
21363 
 
21364 
  thrift_spec = (
21365 
    None, # 0
21366 
    (1, TType.I64, 'orderId', None, None, ), # 1
21367 
    (2, TType.I64, 'addressId', None, None, ), # 2
21368 
  )
21369 
 
21370 
  def __init__(self, orderId=None, addressId=None,):
21371 
    self.orderId = orderId
21372 
    self.addressId = addressId
21373 
 
21374 
  def read(self, iprot):
21375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21377 
      return
21378 
    iprot.readStructBegin()
21379 
    while True:
21380 
      (fname, ftype, fid) = iprot.readFieldBegin()
21381 
      if ftype == TType.STOP:
21382 
        break
21383 
      if fid == 1:
21384 
        if ftype == TType.I64:
21385 
          self.orderId = iprot.readI64();
21386 
        else:
21387 
          iprot.skip(ftype)
21388 
      elif fid == 2:
21389 
        if ftype == TType.I64:
21390 
          self.addressId = iprot.readI64();
21391 
        else:
21392 
          iprot.skip(ftype)
21393 
      else:
21394 
        iprot.skip(ftype)
21395 
      iprot.readFieldEnd()
21396 
    iprot.readStructEnd()
21397 
 
21398 
  def write(self, oprot):
21399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21401 
      return
21402 
    oprot.writeStructBegin('updateShipmentAddress_args')
21403 
    if self.orderId is not None:
21404 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21405 
      oprot.writeI64(self.orderId)
21406 
      oprot.writeFieldEnd()
21407 
    if self.addressId is not None:
21408 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21409 
      oprot.writeI64(self.addressId)
21410 
      oprot.writeFieldEnd()
21411 
    oprot.writeFieldStop()
21412 
    oprot.writeStructEnd()
21413 
 
21414 
  def validate(self):
21415 
    return
21416 
 
21417 
 
21418 
  def __repr__(self):
21419 
    L = ['%s=%r' % (key, value)
21420 
      for key, value in self.__dict__.iteritems()]
21421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21422 
 
21423 
  def __eq__(self, other):
21424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21425 
 
21426 
  def __ne__(self, other):
21427 
    return not (self == other)
21428 
 
21429 
class updateShipmentAddress_result:
21430 
  """
21431 
  Attributes:
21432 
   - ex
21433 
  """
21434 
 
21435 
  thrift_spec = (
21436 
    None, # 0
21437 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21438 
  )
21439 
 
21440 
  def __init__(self, ex=None,):
21441 
    self.ex = ex
21442 
 
21443 
  def read(self, iprot):
21444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21446 
      return
21447 
    iprot.readStructBegin()
21448 
    while True:
21449 
      (fname, ftype, fid) = iprot.readFieldBegin()
21450 
      if ftype == TType.STOP:
21451 
        break
21452 
      if fid == 1:
21453 
        if ftype == TType.STRUCT:
21454 
          self.ex = TransactionServiceException()
21455 
          self.ex.read(iprot)
21456 
        else:
21457 
          iprot.skip(ftype)
21458 
      else:
21459 
        iprot.skip(ftype)
21460 
      iprot.readFieldEnd()
21461 
    iprot.readStructEnd()
21462 
 
21463 
  def write(self, oprot):
21464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21466 
      return
21467 
    oprot.writeStructBegin('updateShipmentAddress_result')
21468 
    if self.ex is not None:
21469 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21470 
      self.ex.write(oprot)
21471 
      oprot.writeFieldEnd()
21472 
    oprot.writeFieldStop()
21473 
    oprot.writeStructEnd()
21474 
 
21475 
  def validate(self):
21476 
    return
21477 
 
21478 
 
21479 
  def __repr__(self):
21480 
    L = ['%s=%r' % (key, value)
21481 
      for key, value in self.__dict__.iteritems()]
21482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21483 
 
21484 
  def __eq__(self, other):
21485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21486 
 
21487 
  def __ne__(self, other):
21488 
    return not (self == other)
21489 
 
4285 rajveer 21490 
class acceptOrdersForItemId_args:
21491 
  """
21492 
  Attributes:
21493 
   - itemId
21494 
   - inventory
21495 
  """
21496 
 
21497 
  thrift_spec = (
21498 
    None, # 0
21499 
    (1, TType.I64, 'itemId', None, None, ), # 1
21500 
    (2, TType.I64, 'inventory', None, None, ), # 2
21501 
  )
21502 
 
21503 
  def __init__(self, itemId=None, inventory=None,):
21504 
    self.itemId = itemId
21505 
    self.inventory = inventory
21506 
 
21507 
  def read(self, iprot):
21508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21510 
      return
21511 
    iprot.readStructBegin()
21512 
    while True:
21513 
      (fname, ftype, fid) = iprot.readFieldBegin()
21514 
      if ftype == TType.STOP:
21515 
        break
21516 
      if fid == 1:
21517 
        if ftype == TType.I64:
21518 
          self.itemId = iprot.readI64();
21519 
        else:
21520 
          iprot.skip(ftype)
21521 
      elif fid == 2:
21522 
        if ftype == TType.I64:
21523 
          self.inventory = iprot.readI64();
21524 
        else:
21525 
          iprot.skip(ftype)
21526 
      else:
21527 
        iprot.skip(ftype)
21528 
      iprot.readFieldEnd()
21529 
    iprot.readStructEnd()
21530 
 
21531 
  def write(self, oprot):
21532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21534 
      return
21535 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21536 
    if self.itemId is not None:
21537 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21538 
      oprot.writeI64(self.itemId)
21539 
      oprot.writeFieldEnd()
21540 
    if self.inventory is not None:
21541 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21542 
      oprot.writeI64(self.inventory)
21543 
      oprot.writeFieldEnd()
21544 
    oprot.writeFieldStop()
21545 
    oprot.writeStructEnd()
21546 
 
21547 
  def validate(self):
21548 
    return
21549 
 
21550 
 
21551 
  def __repr__(self):
21552 
    L = ['%s=%r' % (key, value)
21553 
      for key, value in self.__dict__.iteritems()]
21554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21555 
 
21556 
  def __eq__(self, other):
21557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21558 
 
21559 
  def __ne__(self, other):
21560 
    return not (self == other)
21561 
 
21562 
class acceptOrdersForItemId_result:
21563 
  """
21564 
  Attributes:
21565 
   - success
21566 
   - ex
21567 
  """
21568 
 
21569 
  thrift_spec = (
21570 
    (0, TType.BOOL, 'success', None, None, ), # 0
21571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21572 
  )
21573 
 
21574 
  def __init__(self, success=None, ex=None,):
21575 
    self.success = success
21576 
    self.ex = ex
21577 
 
21578 
  def read(self, iprot):
21579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21581 
      return
21582 
    iprot.readStructBegin()
21583 
    while True:
21584 
      (fname, ftype, fid) = iprot.readFieldBegin()
21585 
      if ftype == TType.STOP:
21586 
        break
21587 
      if fid == 0:
21588 
        if ftype == TType.BOOL:
21589 
          self.success = iprot.readBool();
21590 
        else:
21591 
          iprot.skip(ftype)
21592 
      elif fid == 1:
21593 
        if ftype == TType.STRUCT:
21594 
          self.ex = TransactionServiceException()
21595 
          self.ex.read(iprot)
21596 
        else:
21597 
          iprot.skip(ftype)
21598 
      else:
21599 
        iprot.skip(ftype)
21600 
      iprot.readFieldEnd()
21601 
    iprot.readStructEnd()
21602 
 
21603 
  def write(self, oprot):
21604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21606 
      return
21607 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21608 
    if self.success is not None:
21609 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21610 
      oprot.writeBool(self.success)
21611 
      oprot.writeFieldEnd()
21612 
    if self.ex is not None:
21613 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21614 
      self.ex.write(oprot)
21615 
      oprot.writeFieldEnd()
21616 
    oprot.writeFieldStop()
21617 
    oprot.writeStructEnd()
21618 
 
21619 
  def validate(self):
21620 
    return
21621 
 
21622 
 
21623 
  def __repr__(self):
21624 
    L = ['%s=%r' % (key, value)
21625 
      for key, value in self.__dict__.iteritems()]
21626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21627 
 
21628 
  def __eq__(self, other):
21629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21630 
 
21631 
  def __ne__(self, other):
21632 
    return not (self == other)
4303 rajveer 21633 
 
21634 
class markOrdersAsPORaised_args:
21635 
  """
21636 
  Attributes:
21637 
   - vendorId
21638 
   - itemId
21639 
   - quantity
21640 
   - estimate
4369 rajveer 21641 
   - isReminder
4303 rajveer 21642 
  """
21643 
 
21644 
  thrift_spec = (
21645 
    None, # 0
21646 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21647 
    (2, TType.I64, 'itemId', None, None, ), # 2
21648 
    (3, TType.I64, 'quantity', None, None, ), # 3
21649 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21650 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21651 
  )
21652 
 
4369 rajveer 21653 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21654 
    self.vendorId = vendorId
21655 
    self.itemId = itemId
21656 
    self.quantity = quantity
21657 
    self.estimate = estimate
4369 rajveer 21658 
    self.isReminder = isReminder
4303 rajveer 21659 
 
21660 
  def read(self, iprot):
21661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21663 
      return
21664 
    iprot.readStructBegin()
21665 
    while True:
21666 
      (fname, ftype, fid) = iprot.readFieldBegin()
21667 
      if ftype == TType.STOP:
21668 
        break
21669 
      if fid == 1:
21670 
        if ftype == TType.I64:
21671 
          self.vendorId = iprot.readI64();
21672 
        else:
21673 
          iprot.skip(ftype)
21674 
      elif fid == 2:
21675 
        if ftype == TType.I64:
21676 
          self.itemId = iprot.readI64();
21677 
        else:
21678 
          iprot.skip(ftype)
21679 
      elif fid == 3:
21680 
        if ftype == TType.I64:
21681 
          self.quantity = iprot.readI64();
21682 
        else:
21683 
          iprot.skip(ftype)
21684 
      elif fid == 4:
21685 
        if ftype == TType.I64:
21686 
          self.estimate = iprot.readI64();
21687 
        else:
21688 
          iprot.skip(ftype)
4369 rajveer 21689 
      elif fid == 5:
21690 
        if ftype == TType.BOOL:
21691 
          self.isReminder = iprot.readBool();
21692 
        else:
21693 
          iprot.skip(ftype)
4303 rajveer 21694 
      else:
21695 
        iprot.skip(ftype)
21696 
      iprot.readFieldEnd()
21697 
    iprot.readStructEnd()
21698 
 
21699 
  def write(self, oprot):
21700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21702 
      return
21703 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21704 
    if self.vendorId is not None:
21705 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21706 
      oprot.writeI64(self.vendorId)
21707 
      oprot.writeFieldEnd()
21708 
    if self.itemId is not None:
21709 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21710 
      oprot.writeI64(self.itemId)
21711 
      oprot.writeFieldEnd()
21712 
    if self.quantity is not None:
21713 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21714 
      oprot.writeI64(self.quantity)
21715 
      oprot.writeFieldEnd()
21716 
    if self.estimate is not None:
21717 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21718 
      oprot.writeI64(self.estimate)
21719 
      oprot.writeFieldEnd()
4369 rajveer 21720 
    if self.isReminder is not None:
21721 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21722 
      oprot.writeBool(self.isReminder)
21723 
      oprot.writeFieldEnd()
4303 rajveer 21724 
    oprot.writeFieldStop()
21725 
    oprot.writeStructEnd()
21726 
 
21727 
  def validate(self):
21728 
    return
21729 
 
21730 
 
21731 
  def __repr__(self):
21732 
    L = ['%s=%r' % (key, value)
21733 
      for key, value in self.__dict__.iteritems()]
21734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21735 
 
21736 
  def __eq__(self, other):
21737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21738 
 
21739 
  def __ne__(self, other):
21740 
    return not (self == other)
21741 
 
21742 
class markOrdersAsPORaised_result:
21743 
  """
21744 
  Attributes:
21745 
   - ex
21746 
  """
21747 
 
21748 
  thrift_spec = (
21749 
    None, # 0
21750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21751 
  )
21752 
 
21753 
  def __init__(self, ex=None,):
21754 
    self.ex = ex
21755 
 
21756 
  def read(self, iprot):
21757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21759 
      return
21760 
    iprot.readStructBegin()
21761 
    while True:
21762 
      (fname, ftype, fid) = iprot.readFieldBegin()
21763 
      if ftype == TType.STOP:
21764 
        break
21765 
      if fid == 1:
21766 
        if ftype == TType.STRUCT:
21767 
          self.ex = TransactionServiceException()
21768 
          self.ex.read(iprot)
21769 
        else:
21770 
          iprot.skip(ftype)
21771 
      else:
21772 
        iprot.skip(ftype)
21773 
      iprot.readFieldEnd()
21774 
    iprot.readStructEnd()
21775 
 
21776 
  def write(self, oprot):
21777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21779 
      return
21780 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21781 
    if self.ex is not None:
21782 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21783 
      self.ex.write(oprot)
21784 
      oprot.writeFieldEnd()
21785 
    oprot.writeFieldStop()
21786 
    oprot.writeStructEnd()
21787 
 
21788 
  def validate(self):
21789 
    return
21790 
 
21791 
 
21792 
  def __repr__(self):
21793 
    L = ['%s=%r' % (key, value)
21794 
      for key, value in self.__dict__.iteritems()]
21795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21796 
 
21797 
  def __eq__(self, other):
21798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21799 
 
21800 
  def __ne__(self, other):
21801 
    return not (self == other)
21802 
 
21803 
class markOrdersAsReversalInitiated_args:
21804 
  """
21805 
  Attributes:
21806 
   - vendorId
21807 
   - itemId
21808 
   - quantity
21809 
   - estimate
4369 rajveer 21810 
   - isReminder
4303 rajveer 21811 
  """
21812 
 
21813 
  thrift_spec = (
21814 
    None, # 0
21815 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21816 
    (2, TType.I64, 'itemId', None, None, ), # 2
21817 
    (3, TType.I64, 'quantity', None, None, ), # 3
21818 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21819 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21820 
  )
21821 
 
4369 rajveer 21822 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21823 
    self.vendorId = vendorId
21824 
    self.itemId = itemId
21825 
    self.quantity = quantity
21826 
    self.estimate = estimate
4369 rajveer 21827 
    self.isReminder = isReminder
4303 rajveer 21828 
 
21829 
  def read(self, iprot):
21830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21832 
      return
21833 
    iprot.readStructBegin()
21834 
    while True:
21835 
      (fname, ftype, fid) = iprot.readFieldBegin()
21836 
      if ftype == TType.STOP:
21837 
        break
21838 
      if fid == 1:
21839 
        if ftype == TType.I64:
21840 
          self.vendorId = iprot.readI64();
21841 
        else:
21842 
          iprot.skip(ftype)
21843 
      elif fid == 2:
21844 
        if ftype == TType.I64:
21845 
          self.itemId = iprot.readI64();
21846 
        else:
21847 
          iprot.skip(ftype)
21848 
      elif fid == 3:
21849 
        if ftype == TType.I64:
21850 
          self.quantity = iprot.readI64();
21851 
        else:
21852 
          iprot.skip(ftype)
21853 
      elif fid == 4:
21854 
        if ftype == TType.I64:
21855 
          self.estimate = iprot.readI64();
21856 
        else:
21857 
          iprot.skip(ftype)
4369 rajveer 21858 
      elif fid == 5:
21859 
        if ftype == TType.BOOL:
21860 
          self.isReminder = iprot.readBool();
21861 
        else:
21862 
          iprot.skip(ftype)
4303 rajveer 21863 
      else:
21864 
        iprot.skip(ftype)
21865 
      iprot.readFieldEnd()
21866 
    iprot.readStructEnd()
21867 
 
21868 
  def write(self, oprot):
21869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21871 
      return
21872 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21873 
    if self.vendorId is not None:
21874 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21875 
      oprot.writeI64(self.vendorId)
21876 
      oprot.writeFieldEnd()
21877 
    if self.itemId is not None:
21878 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21879 
      oprot.writeI64(self.itemId)
21880 
      oprot.writeFieldEnd()
21881 
    if self.quantity is not None:
21882 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21883 
      oprot.writeI64(self.quantity)
21884 
      oprot.writeFieldEnd()
21885 
    if self.estimate is not None:
21886 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21887 
      oprot.writeI64(self.estimate)
21888 
      oprot.writeFieldEnd()
4369 rajveer 21889 
    if self.isReminder is not None:
21890 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21891 
      oprot.writeBool(self.isReminder)
21892 
      oprot.writeFieldEnd()
4303 rajveer 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 
 
21911 
class markOrdersAsReversalInitiated_result:
21912 
  """
21913 
  Attributes:
21914 
   - ex
21915 
  """
21916 
 
21917 
  thrift_spec = (
21918 
    None, # 0
21919 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21920 
  )
21921 
 
21922 
  def __init__(self, ex=None,):
21923 
    self.ex = ex
21924 
 
21925 
  def read(self, iprot):
21926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21928 
      return
21929 
    iprot.readStructBegin()
21930 
    while True:
21931 
      (fname, ftype, fid) = iprot.readFieldBegin()
21932 
      if ftype == TType.STOP:
21933 
        break
21934 
      if fid == 1:
21935 
        if ftype == TType.STRUCT:
21936 
          self.ex = TransactionServiceException()
21937 
          self.ex.read(iprot)
21938 
        else:
21939 
          iprot.skip(ftype)
21940 
      else:
21941 
        iprot.skip(ftype)
21942 
      iprot.readFieldEnd()
21943 
    iprot.readStructEnd()
21944 
 
21945 
  def write(self, oprot):
21946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21948 
      return
21949 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21950 
    if self.ex is not None:
21951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21952 
      self.ex.write(oprot)
21953 
      oprot.writeFieldEnd()
21954 
    oprot.writeFieldStop()
21955 
    oprot.writeStructEnd()
21956 
 
21957 
  def validate(self):
21958 
    return
21959 
 
21960 
 
21961 
  def __repr__(self):
21962 
    L = ['%s=%r' % (key, value)
21963 
      for key, value in self.__dict__.iteritems()]
21964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21965 
 
21966 
  def __eq__(self, other):
21967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21968 
 
21969 
  def __ne__(self, other):
21970 
    return not (self == other)
21971 
 
21972 
class markOrdersAsNotAvailabke_args:
21973 
  """
21974 
  Attributes:
21975 
   - vendorId
21976 
   - itemId
21977 
   - quantity
21978 
   - estimate
4369 rajveer 21979 
   - isReminder
4303 rajveer 21980 
  """
21981 
 
21982 
  thrift_spec = (
21983 
    None, # 0
21984 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21985 
    (2, TType.I64, 'itemId', None, None, ), # 2
21986 
    (3, TType.I64, 'quantity', None, None, ), # 3
21987 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21988 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21989 
  )
21990 
 
4369 rajveer 21991 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21992 
    self.vendorId = vendorId
21993 
    self.itemId = itemId
21994 
    self.quantity = quantity
21995 
    self.estimate = estimate
4369 rajveer 21996 
    self.isReminder = isReminder
4303 rajveer 21997 
 
21998 
  def read(self, iprot):
21999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22001 
      return
22002 
    iprot.readStructBegin()
22003 
    while True:
22004 
      (fname, ftype, fid) = iprot.readFieldBegin()
22005 
      if ftype == TType.STOP:
22006 
        break
22007 
      if fid == 1:
22008 
        if ftype == TType.I64:
22009 
          self.vendorId = iprot.readI64();
22010 
        else:
22011 
          iprot.skip(ftype)
22012 
      elif fid == 2:
22013 
        if ftype == TType.I64:
22014 
          self.itemId = iprot.readI64();
22015 
        else:
22016 
          iprot.skip(ftype)
22017 
      elif fid == 3:
22018 
        if ftype == TType.I64:
22019 
          self.quantity = iprot.readI64();
22020 
        else:
22021 
          iprot.skip(ftype)
22022 
      elif fid == 4:
22023 
        if ftype == TType.I64:
22024 
          self.estimate = iprot.readI64();
22025 
        else:
22026 
          iprot.skip(ftype)
4369 rajveer 22027 
      elif fid == 5:
22028 
        if ftype == TType.BOOL:
22029 
          self.isReminder = iprot.readBool();
22030 
        else:
22031 
          iprot.skip(ftype)
4303 rajveer 22032 
      else:
22033 
        iprot.skip(ftype)
22034 
      iprot.readFieldEnd()
22035 
    iprot.readStructEnd()
22036 
 
22037 
  def write(self, oprot):
22038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22040 
      return
22041 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22042 
    if self.vendorId is not None:
22043 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22044 
      oprot.writeI64(self.vendorId)
22045 
      oprot.writeFieldEnd()
22046 
    if self.itemId is not None:
22047 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22048 
      oprot.writeI64(self.itemId)
22049 
      oprot.writeFieldEnd()
22050 
    if self.quantity is not None:
22051 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22052 
      oprot.writeI64(self.quantity)
22053 
      oprot.writeFieldEnd()
22054 
    if self.estimate is not None:
22055 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22056 
      oprot.writeI64(self.estimate)
22057 
      oprot.writeFieldEnd()
4369 rajveer 22058 
    if self.isReminder is not None:
22059 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22060 
      oprot.writeBool(self.isReminder)
22061 
      oprot.writeFieldEnd()
4303 rajveer 22062 
    oprot.writeFieldStop()
22063 
    oprot.writeStructEnd()
22064 
 
22065 
  def validate(self):
22066 
    return
22067 
 
22068 
 
22069 
  def __repr__(self):
22070 
    L = ['%s=%r' % (key, value)
22071 
      for key, value in self.__dict__.iteritems()]
22072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22073 
 
22074 
  def __eq__(self, other):
22075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22076 
 
22077 
  def __ne__(self, other):
22078 
    return not (self == other)
22079 
 
22080 
class markOrdersAsNotAvailabke_result:
22081 
  """
22082 
  Attributes:
22083 
   - ex
22084 
  """
22085 
 
22086 
  thrift_spec = (
22087 
    None, # 0
22088 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22089 
  )
22090 
 
22091 
  def __init__(self, ex=None,):
22092 
    self.ex = ex
22093 
 
22094 
  def read(self, iprot):
22095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22097 
      return
22098 
    iprot.readStructBegin()
22099 
    while True:
22100 
      (fname, ftype, fid) = iprot.readFieldBegin()
22101 
      if ftype == TType.STOP:
22102 
        break
22103 
      if fid == 1:
22104 
        if ftype == TType.STRUCT:
22105 
          self.ex = TransactionServiceException()
22106 
          self.ex.read(iprot)
22107 
        else:
22108 
          iprot.skip(ftype)
22109 
      else:
22110 
        iprot.skip(ftype)
22111 
      iprot.readFieldEnd()
22112 
    iprot.readStructEnd()
22113 
 
22114 
  def write(self, oprot):
22115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22117 
      return
22118 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22119 
    if self.ex is not None:
22120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22121 
      self.ex.write(oprot)
22122 
      oprot.writeFieldEnd()
22123 
    oprot.writeFieldStop()
22124 
    oprot.writeStructEnd()
22125 
 
22126 
  def validate(self):
22127 
    return
22128 
 
22129 
 
22130 
  def __repr__(self):
22131 
    L = ['%s=%r' % (key, value)
22132 
      for key, value in self.__dict__.iteritems()]
22133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22134 
 
22135 
  def __eq__(self, other):
22136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22137 
 
22138 
  def __ne__(self, other):
22139 
    return not (self == other)
4369 rajveer 22140 
 
22141 
class markOrdersAsTimeout_args:
22142 
  """
22143 
  Attributes:
22144 
   - vendorId
22145 
  """
22146 
 
22147 
  thrift_spec = (
22148 
    None, # 0
22149 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22150 
  )
22151 
 
22152 
  def __init__(self, vendorId=None,):
22153 
    self.vendorId = vendorId
22154 
 
22155 
  def read(self, iprot):
22156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22158 
      return
22159 
    iprot.readStructBegin()
22160 
    while True:
22161 
      (fname, ftype, fid) = iprot.readFieldBegin()
22162 
      if ftype == TType.STOP:
22163 
        break
22164 
      if fid == 1:
22165 
        if ftype == TType.I64:
22166 
          self.vendorId = iprot.readI64();
22167 
        else:
22168 
          iprot.skip(ftype)
22169 
      else:
22170 
        iprot.skip(ftype)
22171 
      iprot.readFieldEnd()
22172 
    iprot.readStructEnd()
22173 
 
22174 
  def write(self, oprot):
22175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22177 
      return
22178 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22179 
    if self.vendorId is not None:
22180 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22181 
      oprot.writeI64(self.vendorId)
22182 
      oprot.writeFieldEnd()
22183 
    oprot.writeFieldStop()
22184 
    oprot.writeStructEnd()
22185 
 
22186 
  def validate(self):
22187 
    return
22188 
 
22189 
 
22190 
  def __repr__(self):
22191 
    L = ['%s=%r' % (key, value)
22192 
      for key, value in self.__dict__.iteritems()]
22193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22194 
 
22195 
  def __eq__(self, other):
22196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22197 
 
22198 
  def __ne__(self, other):
22199 
    return not (self == other)
22200 
 
22201 
class markOrdersAsTimeout_result:
22202 
  """
22203 
  Attributes:
22204 
   - success
22205 
   - ex
22206 
  """
22207 
 
22208 
  thrift_spec = (
22209 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22210 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22211 
  )
22212 
 
22213 
  def __init__(self, success=None, ex=None,):
22214 
    self.success = success
22215 
    self.ex = ex
22216 
 
22217 
  def read(self, iprot):
22218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22220 
      return
22221 
    iprot.readStructBegin()
22222 
    while True:
22223 
      (fname, ftype, fid) = iprot.readFieldBegin()
22224 
      if ftype == TType.STOP:
22225 
        break
22226 
      if fid == 0:
22227 
        if ftype == TType.MAP:
22228 
          self.success = {}
6188 rajveer 22229 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22230 
          for _i505 in xrange(_size501):
22231 
            _key506 = iprot.readI32();
22232 
            _val507 = TimeoutSummary()
22233 
            _val507.read(iprot)
22234 
            self.success[_key506] = _val507
4369 rajveer 22235 
          iprot.readMapEnd()
22236 
        else:
22237 
          iprot.skip(ftype)
22238 
      elif fid == 1:
22239 
        if ftype == TType.STRUCT:
22240 
          self.ex = TransactionServiceException()
22241 
          self.ex.read(iprot)
22242 
        else:
22243 
          iprot.skip(ftype)
22244 
      else:
22245 
        iprot.skip(ftype)
22246 
      iprot.readFieldEnd()
22247 
    iprot.readStructEnd()
22248 
 
22249 
  def write(self, oprot):
22250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22252 
      return
22253 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22254 
    if self.success is not None:
22255 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22256 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22257 
      for kiter508,viter509 in self.success.items():
22258 
        oprot.writeI32(kiter508)
22259 
        viter509.write(oprot)
4369 rajveer 22260 
      oprot.writeMapEnd()
22261 
      oprot.writeFieldEnd()
22262 
    if self.ex is not None:
22263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22264 
      self.ex.write(oprot)
22265 
      oprot.writeFieldEnd()
22266 
    oprot.writeFieldStop()
22267 
    oprot.writeStructEnd()
22268 
 
22269 
  def validate(self):
22270 
    return
22271 
 
22272 
 
22273 
  def __repr__(self):
22274 
    L = ['%s=%r' % (key, value)
22275 
      for key, value in self.__dict__.iteritems()]
22276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22277 
 
22278 
  def __eq__(self, other):
22279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22280 
 
22281 
  def __ne__(self, other):
22282 
    return not (self == other)
4386 anupam.sin 22283 
 
4662 rajveer 22284 
class markOrderAsLostInTransit_args:
22285 
  """
22286 
  Attributes:
22287 
   - orderId
22288 
  """
22289 
 
22290 
  thrift_spec = (
22291 
    None, # 0
22292 
    (1, TType.I64, 'orderId', None, None, ), # 1
22293 
  )
22294 
 
22295 
  def __init__(self, orderId=None,):
22296 
    self.orderId = orderId
22297 
 
22298 
  def read(self, iprot):
22299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22301 
      return
22302 
    iprot.readStructBegin()
22303 
    while True:
22304 
      (fname, ftype, fid) = iprot.readFieldBegin()
22305 
      if ftype == TType.STOP:
22306 
        break
22307 
      if fid == 1:
22308 
        if ftype == TType.I64:
22309 
          self.orderId = iprot.readI64();
22310 
        else:
22311 
          iprot.skip(ftype)
22312 
      else:
22313 
        iprot.skip(ftype)
22314 
      iprot.readFieldEnd()
22315 
    iprot.readStructEnd()
22316 
 
22317 
  def write(self, oprot):
22318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22320 
      return
22321 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22322 
    if self.orderId is not None:
22323 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22324 
      oprot.writeI64(self.orderId)
22325 
      oprot.writeFieldEnd()
22326 
    oprot.writeFieldStop()
22327 
    oprot.writeStructEnd()
22328 
 
22329 
  def validate(self):
22330 
    return
22331 
 
22332 
 
22333 
  def __repr__(self):
22334 
    L = ['%s=%r' % (key, value)
22335 
      for key, value in self.__dict__.iteritems()]
22336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22337 
 
22338 
  def __eq__(self, other):
22339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22340 
 
22341 
  def __ne__(self, other):
22342 
    return not (self == other)
22343 
 
22344 
class markOrderAsLostInTransit_result:
22345 
  """
22346 
  Attributes:
22347 
   - success
22348 
   - ex
22349 
  """
22350 
 
22351 
  thrift_spec = (
22352 
    (0, TType.BOOL, 'success', None, None, ), # 0
22353 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22354 
  )
22355 
 
22356 
  def __init__(self, success=None, ex=None,):
22357 
    self.success = success
22358 
    self.ex = ex
22359 
 
22360 
  def read(self, iprot):
22361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22363 
      return
22364 
    iprot.readStructBegin()
22365 
    while True:
22366 
      (fname, ftype, fid) = iprot.readFieldBegin()
22367 
      if ftype == TType.STOP:
22368 
        break
22369 
      if fid == 0:
22370 
        if ftype == TType.BOOL:
22371 
          self.success = iprot.readBool();
22372 
        else:
22373 
          iprot.skip(ftype)
22374 
      elif fid == 1:
22375 
        if ftype == TType.STRUCT:
22376 
          self.ex = TransactionServiceException()
22377 
          self.ex.read(iprot)
22378 
        else:
22379 
          iprot.skip(ftype)
22380 
      else:
22381 
        iprot.skip(ftype)
22382 
      iprot.readFieldEnd()
22383 
    iprot.readStructEnd()
22384 
 
22385 
  def write(self, oprot):
22386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22388 
      return
22389 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22390 
    if self.success is not None:
22391 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22392 
      oprot.writeBool(self.success)
22393 
      oprot.writeFieldEnd()
22394 
    if self.ex is not None:
22395 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22396 
      self.ex.write(oprot)
22397 
      oprot.writeFieldEnd()
22398 
    oprot.writeFieldStop()
22399 
    oprot.writeStructEnd()
22400 
 
22401 
  def validate(self):
22402 
    return
22403 
 
22404 
 
22405 
  def __repr__(self):
22406 
    L = ['%s=%r' % (key, value)
22407 
      for key, value in self.__dict__.iteritems()]
22408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22409 
 
22410 
  def __eq__(self, other):
22411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22412 
 
22413 
  def __ne__(self, other):
22414 
    return not (self == other)
22415 
 
4386 anupam.sin 22416 
class getOrderForAwb_args:
22417 
  """
22418 
  Attributes:
22419 
   - awb
22420 
  """
22421 
 
22422 
  thrift_spec = (
22423 
    None, # 0
22424 
    (1, TType.STRING, 'awb', None, None, ), # 1
22425 
  )
22426 
 
22427 
  def __init__(self, awb=None,):
22428 
    self.awb = awb
22429 
 
22430 
  def read(self, iprot):
22431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22433 
      return
22434 
    iprot.readStructBegin()
22435 
    while True:
22436 
      (fname, ftype, fid) = iprot.readFieldBegin()
22437 
      if ftype == TType.STOP:
22438 
        break
22439 
      if fid == 1:
22440 
        if ftype == TType.STRING:
22441 
          self.awb = iprot.readString();
22442 
        else:
22443 
          iprot.skip(ftype)
22444 
      else:
22445 
        iprot.skip(ftype)
22446 
      iprot.readFieldEnd()
22447 
    iprot.readStructEnd()
22448 
 
22449 
  def write(self, oprot):
22450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22452 
      return
22453 
    oprot.writeStructBegin('getOrderForAwb_args')
22454 
    if self.awb is not None:
22455 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22456 
      oprot.writeString(self.awb)
22457 
      oprot.writeFieldEnd()
22458 
    oprot.writeFieldStop()
22459 
    oprot.writeStructEnd()
22460 
 
22461 
  def validate(self):
22462 
    return
22463 
 
22464 
 
22465 
  def __repr__(self):
22466 
    L = ['%s=%r' % (key, value)
22467 
      for key, value in self.__dict__.iteritems()]
22468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22469 
 
22470 
  def __eq__(self, other):
22471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22472 
 
22473 
  def __ne__(self, other):
22474 
    return not (self == other)
22475 
 
22476 
class getOrderForAwb_result:
22477 
  """
22478 
  Attributes:
22479 
   - success
22480 
   - ex
22481 
  """
22482 
 
22483 
  thrift_spec = (
22484 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22485 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22486 
  )
22487 
 
22488 
  def __init__(self, success=None, ex=None,):
22489 
    self.success = success
22490 
    self.ex = ex
22491 
 
22492 
  def read(self, iprot):
22493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22495 
      return
22496 
    iprot.readStructBegin()
22497 
    while True:
22498 
      (fname, ftype, fid) = iprot.readFieldBegin()
22499 
      if ftype == TType.STOP:
22500 
        break
22501 
      if fid == 0:
22502 
        if ftype == TType.STRUCT:
22503 
          self.success = Order()
22504 
          self.success.read(iprot)
22505 
        else:
22506 
          iprot.skip(ftype)
22507 
      elif fid == 1:
22508 
        if ftype == TType.STRUCT:
22509 
          self.ex = TransactionServiceException()
22510 
          self.ex.read(iprot)
22511 
        else:
22512 
          iprot.skip(ftype)
22513 
      else:
22514 
        iprot.skip(ftype)
22515 
      iprot.readFieldEnd()
22516 
    iprot.readStructEnd()
22517 
 
22518 
  def write(self, oprot):
22519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22521 
      return
22522 
    oprot.writeStructBegin('getOrderForAwb_result')
22523 
    if self.success is not None:
22524 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22525 
      self.success.write(oprot)
22526 
      oprot.writeFieldEnd()
22527 
    if self.ex is not None:
22528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22529 
      self.ex.write(oprot)
22530 
      oprot.writeFieldEnd()
22531 
    oprot.writeFieldStop()
22532 
    oprot.writeStructEnd()
22533 
 
22534 
  def validate(self):
22535 
    return
22536 
 
22537 
 
22538 
  def __repr__(self):
22539 
    L = ['%s=%r' % (key, value)
22540 
      for key, value in self.__dict__.iteritems()]
22541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22542 
 
22543 
  def __eq__(self, other):
22544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22545 
 
22546 
  def __ne__(self, other):
22547 
    return not (self == other)
4506 phani.kuma 22548 
 
22549 
class getOrdersForProviderForStatus_args:
22550 
  """
22551 
  Attributes:
22552 
   - logistics_provider_id
4910 phani.kuma 22553 
   - order_status_list
4506 phani.kuma 22554 
  """
22555 
 
22556 
  thrift_spec = (
22557 
    None, # 0
22558 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22559 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22560 
  )
22561 
 
4910 phani.kuma 22562 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22563 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22564 
    self.order_status_list = order_status_list
4506 phani.kuma 22565 
 
22566 
  def read(self, iprot):
22567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22569 
      return
22570 
    iprot.readStructBegin()
22571 
    while True:
22572 
      (fname, ftype, fid) = iprot.readFieldBegin()
22573 
      if ftype == TType.STOP:
22574 
        break
22575 
      if fid == 1:
22576 
        if ftype == TType.I64:
22577 
          self.logistics_provider_id = iprot.readI64();
22578 
        else:
22579 
          iprot.skip(ftype)
22580 
      elif fid == 2:
4910 phani.kuma 22581 
        if ftype == TType.LIST:
22582 
          self.order_status_list = []
6188 rajveer 22583 
          (_etype513, _size510) = iprot.readListBegin()
22584 
          for _i514 in xrange(_size510):
22585 
            _elem515 = iprot.readI32();
22586 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22587 
          iprot.readListEnd()
4506 phani.kuma 22588 
        else:
22589 
          iprot.skip(ftype)
22590 
      else:
22591 
        iprot.skip(ftype)
22592 
      iprot.readFieldEnd()
22593 
    iprot.readStructEnd()
22594 
 
22595 
  def write(self, oprot):
22596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22598 
      return
22599 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22600 
    if self.logistics_provider_id is not None:
22601 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22602 
      oprot.writeI64(self.logistics_provider_id)
22603 
      oprot.writeFieldEnd()
4910 phani.kuma 22604 
    if self.order_status_list is not None:
22605 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22606 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22607 
      for iter516 in self.order_status_list:
22608 
        oprot.writeI32(iter516)
4910 phani.kuma 22609 
      oprot.writeListEnd()
4506 phani.kuma 22610 
      oprot.writeFieldEnd()
22611 
    oprot.writeFieldStop()
22612 
    oprot.writeStructEnd()
22613 
 
22614 
  def validate(self):
22615 
    return
22616 
 
22617 
 
22618 
  def __repr__(self):
22619 
    L = ['%s=%r' % (key, value)
22620 
      for key, value in self.__dict__.iteritems()]
22621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22622 
 
22623 
  def __eq__(self, other):
22624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22625 
 
22626 
  def __ne__(self, other):
22627 
    return not (self == other)
22628 
 
22629 
class getOrdersForProviderForStatus_result:
22630 
  """
22631 
  Attributes:
22632 
   - success
22633 
   - ex
22634 
  """
22635 
 
22636 
  thrift_spec = (
22637 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22638 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22639 
  )
22640 
 
22641 
  def __init__(self, success=None, ex=None,):
22642 
    self.success = success
22643 
    self.ex = ex
22644 
 
22645 
  def read(self, iprot):
22646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22648 
      return
22649 
    iprot.readStructBegin()
22650 
    while True:
22651 
      (fname, ftype, fid) = iprot.readFieldBegin()
22652 
      if ftype == TType.STOP:
22653 
        break
22654 
      if fid == 0:
22655 
        if ftype == TType.LIST:
22656 
          self.success = []
6188 rajveer 22657 
          (_etype520, _size517) = iprot.readListBegin()
22658 
          for _i521 in xrange(_size517):
22659 
            _elem522 = Order()
22660 
            _elem522.read(iprot)
22661 
            self.success.append(_elem522)
4506 phani.kuma 22662 
          iprot.readListEnd()
22663 
        else:
22664 
          iprot.skip(ftype)
22665 
      elif fid == 1:
22666 
        if ftype == TType.STRUCT:
22667 
          self.ex = TransactionServiceException()
22668 
          self.ex.read(iprot)
22669 
        else:
22670 
          iprot.skip(ftype)
22671 
      else:
22672 
        iprot.skip(ftype)
22673 
      iprot.readFieldEnd()
22674 
    iprot.readStructEnd()
22675 
 
22676 
  def write(self, oprot):
22677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22679 
      return
22680 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22681 
    if self.success is not None:
22682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22683 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22684 
      for iter523 in self.success:
22685 
        iter523.write(oprot)
4506 phani.kuma 22686 
      oprot.writeListEnd()
22687 
      oprot.writeFieldEnd()
22688 
    if self.ex is not None:
22689 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22690 
      self.ex.write(oprot)
22691 
      oprot.writeFieldEnd()
22692 
    oprot.writeFieldStop()
22693 
    oprot.writeStructEnd()
22694 
 
22695 
  def validate(self):
22696 
    return
22697 
 
22698 
 
22699 
  def __repr__(self):
22700 
    L = ['%s=%r' % (key, value)
22701 
      for key, value in self.__dict__.iteritems()]
22702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22703 
 
22704 
  def __eq__(self, other):
22705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22706 
 
22707 
  def __ne__(self, other):
22708 
    return not (self == other)
4600 varun.gupt 22709 
 
22710 
class getBilledOrdersForVendor_args:
22711 
  """
22712 
  Attributes:
22713 
   - vendorId
22714 
   - billingDateFrom
22715 
   - billingDateTo
22716 
  """
22717 
 
22718 
  thrift_spec = (
22719 
    None, # 0
22720 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22721 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22722 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22723 
  )
22724 
 
22725 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22726 
    self.vendorId = vendorId
22727 
    self.billingDateFrom = billingDateFrom
22728 
    self.billingDateTo = billingDateTo
22729 
 
22730 
  def read(self, iprot):
22731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22733 
      return
22734 
    iprot.readStructBegin()
22735 
    while True:
22736 
      (fname, ftype, fid) = iprot.readFieldBegin()
22737 
      if ftype == TType.STOP:
22738 
        break
22739 
      if fid == 1:
22740 
        if ftype == TType.I64:
22741 
          self.vendorId = iprot.readI64();
22742 
        else:
22743 
          iprot.skip(ftype)
22744 
      elif fid == 2:
22745 
        if ftype == TType.I64:
22746 
          self.billingDateFrom = iprot.readI64();
22747 
        else:
22748 
          iprot.skip(ftype)
22749 
      elif fid == 3:
22750 
        if ftype == TType.I64:
22751 
          self.billingDateTo = iprot.readI64();
22752 
        else:
22753 
          iprot.skip(ftype)
22754 
      else:
22755 
        iprot.skip(ftype)
22756 
      iprot.readFieldEnd()
22757 
    iprot.readStructEnd()
22758 
 
22759 
  def write(self, oprot):
22760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22762 
      return
22763 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22764 
    if self.vendorId is not None:
22765 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22766 
      oprot.writeI64(self.vendorId)
22767 
      oprot.writeFieldEnd()
22768 
    if self.billingDateFrom is not None:
22769 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22770 
      oprot.writeI64(self.billingDateFrom)
22771 
      oprot.writeFieldEnd()
22772 
    if self.billingDateTo is not None:
22773 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22774 
      oprot.writeI64(self.billingDateTo)
22775 
      oprot.writeFieldEnd()
22776 
    oprot.writeFieldStop()
22777 
    oprot.writeStructEnd()
22778 
 
22779 
  def validate(self):
22780 
    return
22781 
 
22782 
 
22783 
  def __repr__(self):
22784 
    L = ['%s=%r' % (key, value)
22785 
      for key, value in self.__dict__.iteritems()]
22786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22787 
 
22788 
  def __eq__(self, other):
22789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22790 
 
22791 
  def __ne__(self, other):
22792 
    return not (self == other)
22793 
 
22794 
class getBilledOrdersForVendor_result:
22795 
  """
22796 
  Attributes:
22797 
   - success
22798 
   - ex
22799 
  """
22800 
 
22801 
  thrift_spec = (
22802 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22803 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22804 
  )
22805 
 
22806 
  def __init__(self, success=None, ex=None,):
22807 
    self.success = success
22808 
    self.ex = ex
22809 
 
22810 
  def read(self, iprot):
22811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22813 
      return
22814 
    iprot.readStructBegin()
22815 
    while True:
22816 
      (fname, ftype, fid) = iprot.readFieldBegin()
22817 
      if ftype == TType.STOP:
22818 
        break
22819 
      if fid == 0:
22820 
        if ftype == TType.LIST:
22821 
          self.success = []
6188 rajveer 22822 
          (_etype527, _size524) = iprot.readListBegin()
22823 
          for _i528 in xrange(_size524):
22824 
            _elem529 = Order()
22825 
            _elem529.read(iprot)
22826 
            self.success.append(_elem529)
4600 varun.gupt 22827 
          iprot.readListEnd()
22828 
        else:
22829 
          iprot.skip(ftype)
22830 
      elif fid == 1:
22831 
        if ftype == TType.STRUCT:
22832 
          self.ex = TransactionServiceException()
22833 
          self.ex.read(iprot)
22834 
        else:
22835 
          iprot.skip(ftype)
22836 
      else:
22837 
        iprot.skip(ftype)
22838 
      iprot.readFieldEnd()
22839 
    iprot.readStructEnd()
22840 
 
22841 
  def write(self, oprot):
22842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22844 
      return
22845 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22846 
    if self.success is not None:
22847 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22848 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22849 
      for iter530 in self.success:
22850 
        iter530.write(oprot)
4600 varun.gupt 22851 
      oprot.writeListEnd()
22852 
      oprot.writeFieldEnd()
22853 
    if self.ex is not None:
22854 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22855 
      self.ex.write(oprot)
22856 
      oprot.writeFieldEnd()
22857 
    oprot.writeFieldStop()
22858 
    oprot.writeStructEnd()
22859 
 
22860 
  def validate(self):
22861 
    return
22862 
 
22863 
 
22864 
  def __repr__(self):
22865 
    L = ['%s=%r' % (key, value)
22866 
      for key, value in self.__dict__.iteritems()]
22867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22868 
 
22869 
  def __eq__(self, other):
22870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22871 
 
22872 
  def __ne__(self, other):
22873 
    return not (self == other)
22874 
 
4607 rajveer 22875 
class getSlippedSippingDateOrders_args:
22876 
 
22877 
  thrift_spec = (
22878 
  )
22879 
 
22880 
  def read(self, iprot):
22881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22883 
      return
22884 
    iprot.readStructBegin()
22885 
    while True:
22886 
      (fname, ftype, fid) = iprot.readFieldBegin()
22887 
      if ftype == TType.STOP:
22888 
        break
22889 
      else:
22890 
        iprot.skip(ftype)
22891 
      iprot.readFieldEnd()
22892 
    iprot.readStructEnd()
22893 
 
22894 
  def write(self, oprot):
22895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22897 
      return
22898 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22899 
    oprot.writeFieldStop()
22900 
    oprot.writeStructEnd()
22901 
 
22902 
  def validate(self):
22903 
    return
22904 
 
22905 
 
22906 
  def __repr__(self):
22907 
    L = ['%s=%r' % (key, value)
22908 
      for key, value in self.__dict__.iteritems()]
22909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22910 
 
22911 
  def __eq__(self, other):
22912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22913 
 
22914 
  def __ne__(self, other):
22915 
    return not (self == other)
22916 
 
22917 
class getSlippedSippingDateOrders_result:
22918 
  """
22919 
  Attributes:
22920 
   - success
22921 
   - ex
22922 
  """
22923 
 
22924 
  thrift_spec = (
22925 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22926 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22927 
  )
22928 
 
22929 
  def __init__(self, success=None, ex=None,):
22930 
    self.success = success
22931 
    self.ex = ex
22932 
 
22933 
  def read(self, iprot):
22934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22936 
      return
22937 
    iprot.readStructBegin()
22938 
    while True:
22939 
      (fname, ftype, fid) = iprot.readFieldBegin()
22940 
      if ftype == TType.STOP:
22941 
        break
22942 
      if fid == 0:
22943 
        if ftype == TType.LIST:
22944 
          self.success = []
6188 rajveer 22945 
          (_etype534, _size531) = iprot.readListBegin()
22946 
          for _i535 in xrange(_size531):
22947 
            _elem536 = Order()
22948 
            _elem536.read(iprot)
22949 
            self.success.append(_elem536)
4607 rajveer 22950 
          iprot.readListEnd()
22951 
        else:
22952 
          iprot.skip(ftype)
22953 
      elif fid == 1:
22954 
        if ftype == TType.STRUCT:
22955 
          self.ex = TransactionServiceException()
22956 
          self.ex.read(iprot)
22957 
        else:
22958 
          iprot.skip(ftype)
22959 
      else:
22960 
        iprot.skip(ftype)
22961 
      iprot.readFieldEnd()
22962 
    iprot.readStructEnd()
22963 
 
22964 
  def write(self, oprot):
22965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22967 
      return
22968 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22969 
    if self.success is not None:
22970 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22971 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22972 
      for iter537 in self.success:
22973 
        iter537.write(oprot)
4607 rajveer 22974 
      oprot.writeListEnd()
22975 
      oprot.writeFieldEnd()
22976 
    if self.ex is not None:
22977 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22978 
      self.ex.write(oprot)
22979 
      oprot.writeFieldEnd()
22980 
    oprot.writeFieldStop()
22981 
    oprot.writeStructEnd()
22982 
 
22983 
  def validate(self):
22984 
    return
22985 
 
22986 
 
22987 
  def __repr__(self):
22988 
    L = ['%s=%r' % (key, value)
22989 
      for key, value in self.__dict__.iteritems()]
22990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22991 
 
22992 
  def __eq__(self, other):
22993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22994 
 
22995 
  def __ne__(self, other):
22996 
    return not (self == other)
22997 
 
4709 rajveer 22998 
class getCancelledOrders_args:
22999 
  """
23000 
  Attributes:
23001 
   - cancelDateFrom
23002 
   - cancelDateTo
23003 
  """
23004 
 
23005 
  thrift_spec = (
23006 
    None, # 0
23007 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23008 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23009 
  )
23010 
 
23011 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23012 
    self.cancelDateFrom = cancelDateFrom
23013 
    self.cancelDateTo = cancelDateTo
23014 
 
23015 
  def read(self, iprot):
23016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23018 
      return
23019 
    iprot.readStructBegin()
23020 
    while True:
23021 
      (fname, ftype, fid) = iprot.readFieldBegin()
23022 
      if ftype == TType.STOP:
23023 
        break
23024 
      if fid == 1:
23025 
        if ftype == TType.I64:
23026 
          self.cancelDateFrom = iprot.readI64();
23027 
        else:
23028 
          iprot.skip(ftype)
23029 
      elif fid == 2:
23030 
        if ftype == TType.I64:
23031 
          self.cancelDateTo = iprot.readI64();
23032 
        else:
23033 
          iprot.skip(ftype)
23034 
      else:
23035 
        iprot.skip(ftype)
23036 
      iprot.readFieldEnd()
23037 
    iprot.readStructEnd()
23038 
 
23039 
  def write(self, oprot):
23040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23042 
      return
23043 
    oprot.writeStructBegin('getCancelledOrders_args')
23044 
    if self.cancelDateFrom is not None:
23045 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23046 
      oprot.writeI64(self.cancelDateFrom)
23047 
      oprot.writeFieldEnd()
23048 
    if self.cancelDateTo is not None:
23049 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23050 
      oprot.writeI64(self.cancelDateTo)
23051 
      oprot.writeFieldEnd()
23052 
    oprot.writeFieldStop()
23053 
    oprot.writeStructEnd()
23054 
 
23055 
  def validate(self):
23056 
    return
23057 
 
23058 
 
23059 
  def __repr__(self):
23060 
    L = ['%s=%r' % (key, value)
23061 
      for key, value in self.__dict__.iteritems()]
23062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23063 
 
23064 
  def __eq__(self, other):
23065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23066 
 
23067 
  def __ne__(self, other):
23068 
    return not (self == other)
23069 
 
23070 
class getCancelledOrders_result:
23071 
  """
23072 
  Attributes:
23073 
   - success
23074 
   - ex
23075 
  """
23076 
 
23077 
  thrift_spec = (
23078 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23079 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23080 
  )
23081 
 
23082 
  def __init__(self, success=None, ex=None,):
23083 
    self.success = success
23084 
    self.ex = ex
23085 
 
23086 
  def read(self, iprot):
23087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23089 
      return
23090 
    iprot.readStructBegin()
23091 
    while True:
23092 
      (fname, ftype, fid) = iprot.readFieldBegin()
23093 
      if ftype == TType.STOP:
23094 
        break
23095 
      if fid == 0:
23096 
        if ftype == TType.LIST:
23097 
          self.success = []
6188 rajveer 23098 
          (_etype541, _size538) = iprot.readListBegin()
23099 
          for _i542 in xrange(_size538):
23100 
            _elem543 = Order()
23101 
            _elem543.read(iprot)
23102 
            self.success.append(_elem543)
4709 rajveer 23103 
          iprot.readListEnd()
23104 
        else:
23105 
          iprot.skip(ftype)
23106 
      elif fid == 1:
23107 
        if ftype == TType.STRUCT:
23108 
          self.ex = TransactionServiceException()
23109 
          self.ex.read(iprot)
23110 
        else:
23111 
          iprot.skip(ftype)
23112 
      else:
23113 
        iprot.skip(ftype)
23114 
      iprot.readFieldEnd()
23115 
    iprot.readStructEnd()
23116 
 
23117 
  def write(self, oprot):
23118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23120 
      return
23121 
    oprot.writeStructBegin('getCancelledOrders_result')
23122 
    if self.success is not None:
23123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23124 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23125 
      for iter544 in self.success:
23126 
        iter544.write(oprot)
4709 rajveer 23127 
      oprot.writeListEnd()
23128 
      oprot.writeFieldEnd()
23129 
    if self.ex is not None:
23130 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23131 
      self.ex.write(oprot)
23132 
      oprot.writeFieldEnd()
23133 
    oprot.writeFieldStop()
23134 
    oprot.writeStructEnd()
23135 
 
23136 
  def validate(self):
23137 
    return
23138 
 
23139 
 
23140 
  def __repr__(self):
23141 
    L = ['%s=%r' % (key, value)
23142 
      for key, value in self.__dict__.iteritems()]
23143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23144 
 
23145 
  def __eq__(self, other):
23146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23147 
 
23148 
  def __ne__(self, other):
23149 
    return not (self == other)
23150 
 
4600 varun.gupt 23151 
class saveBluedartSettlements_args:
23152 
  """
23153 
  Attributes:
23154 
   - mapAWBAndAmount
23155 
  """
23156 
 
23157 
  thrift_spec = (
23158 
    None, # 0
23159 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23160 
  )
23161 
 
23162 
  def __init__(self, mapAWBAndAmount=None,):
23163 
    self.mapAWBAndAmount = mapAWBAndAmount
23164 
 
23165 
  def read(self, iprot):
23166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23168 
      return
23169 
    iprot.readStructBegin()
23170 
    while True:
23171 
      (fname, ftype, fid) = iprot.readFieldBegin()
23172 
      if ftype == TType.STOP:
23173 
        break
23174 
      if fid == 1:
23175 
        if ftype == TType.MAP:
23176 
          self.mapAWBAndAmount = {}
6188 rajveer 23177 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23178 
          for _i549 in xrange(_size545):
23179 
            _key550 = iprot.readI64();
23180 
            _val551 = iprot.readDouble();
23181 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23182 
          iprot.readMapEnd()
23183 
        else:
23184 
          iprot.skip(ftype)
23185 
      else:
23186 
        iprot.skip(ftype)
23187 
      iprot.readFieldEnd()
23188 
    iprot.readStructEnd()
23189 
 
23190 
  def write(self, oprot):
23191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23193 
      return
23194 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23195 
    if self.mapAWBAndAmount is not None:
23196 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23197 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23198 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23199 
        oprot.writeI64(kiter552)
23200 
        oprot.writeDouble(viter553)
4600 varun.gupt 23201 
      oprot.writeMapEnd()
23202 
      oprot.writeFieldEnd()
23203 
    oprot.writeFieldStop()
23204 
    oprot.writeStructEnd()
23205 
 
23206 
  def validate(self):
23207 
    return
23208 
 
23209 
 
23210 
  def __repr__(self):
23211 
    L = ['%s=%r' % (key, value)
23212 
      for key, value in self.__dict__.iteritems()]
23213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23214 
 
23215 
  def __eq__(self, other):
23216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23217 
 
23218 
  def __ne__(self, other):
23219 
    return not (self == other)
23220 
 
23221 
class saveBluedartSettlements_result:
23222 
  """
23223 
  Attributes:
23224 
   - ex
23225 
  """
23226 
 
23227 
  thrift_spec = (
23228 
    None, # 0
23229 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23230 
  )
23231 
 
23232 
  def __init__(self, ex=None,):
23233 
    self.ex = ex
23234 
 
23235 
  def read(self, iprot):
23236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23238 
      return
23239 
    iprot.readStructBegin()
23240 
    while True:
23241 
      (fname, ftype, fid) = iprot.readFieldBegin()
23242 
      if ftype == TType.STOP:
23243 
        break
23244 
      if fid == 1:
23245 
        if ftype == TType.STRUCT:
23246 
          self.ex = TransactionServiceException()
23247 
          self.ex.read(iprot)
23248 
        else:
23249 
          iprot.skip(ftype)
23250 
      else:
23251 
        iprot.skip(ftype)
23252 
      iprot.readFieldEnd()
23253 
    iprot.readStructEnd()
23254 
 
23255 
  def write(self, oprot):
23256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23258 
      return
23259 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23260 
    if self.ex is not None:
23261 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23262 
      self.ex.write(oprot)
23263 
      oprot.writeFieldEnd()
23264 
    oprot.writeFieldStop()
23265 
    oprot.writeStructEnd()
23266 
 
23267 
  def validate(self):
23268 
    return
23269 
 
23270 
 
23271 
  def __repr__(self):
23272 
    L = ['%s=%r' % (key, value)
23273 
      for key, value in self.__dict__.iteritems()]
23274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23275 
 
23276 
  def __eq__(self, other):
23277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23278 
 
23279 
  def __ne__(self, other):
23280 
    return not (self == other)
23281 
 
23282 
class savePaymentSettlements_args:
23283 
  """
23284 
  Attributes:
23285 
   - settlementDate
23286 
   - paymentGatewayId
4905 varun.gupt 23287 
   - referenceId
4600 varun.gupt 23288 
   - serviceTax
23289 
   - otherCharges
23290 
   - netCollection
23291 
  """
23292 
 
23293 
  thrift_spec = (
23294 
    None, # 0
23295 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23296 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23297 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23298 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23299 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23300 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23301 
  )
23302 
 
4905 varun.gupt 23303 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23304 
    self.settlementDate = settlementDate
23305 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23306 
    self.referenceId = referenceId
4600 varun.gupt 23307 
    self.serviceTax = serviceTax
23308 
    self.otherCharges = otherCharges
23309 
    self.netCollection = netCollection
23310 
 
23311 
  def read(self, iprot):
23312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23314 
      return
23315 
    iprot.readStructBegin()
23316 
    while True:
23317 
      (fname, ftype, fid) = iprot.readFieldBegin()
23318 
      if ftype == TType.STOP:
23319 
        break
23320 
      if fid == 1:
23321 
        if ftype == TType.I64:
23322 
          self.settlementDate = iprot.readI64();
23323 
        else:
23324 
          iprot.skip(ftype)
23325 
      elif fid == 2:
23326 
        if ftype == TType.I64:
23327 
          self.paymentGatewayId = iprot.readI64();
23328 
        else:
23329 
          iprot.skip(ftype)
23330 
      elif fid == 3:
23331 
        if ftype == TType.I64:
4905 varun.gupt 23332 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23333 
        else:
23334 
          iprot.skip(ftype)
23335 
      elif fid == 4:
23336 
        if ftype == TType.DOUBLE:
23337 
          self.serviceTax = iprot.readDouble();
23338 
        else:
23339 
          iprot.skip(ftype)
23340 
      elif fid == 5:
23341 
        if ftype == TType.DOUBLE:
23342 
          self.otherCharges = iprot.readDouble();
23343 
        else:
23344 
          iprot.skip(ftype)
23345 
      elif fid == 6:
23346 
        if ftype == TType.DOUBLE:
23347 
          self.netCollection = iprot.readDouble();
23348 
        else:
23349 
          iprot.skip(ftype)
23350 
      else:
23351 
        iprot.skip(ftype)
23352 
      iprot.readFieldEnd()
23353 
    iprot.readStructEnd()
23354 
 
23355 
  def write(self, oprot):
23356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23358 
      return
23359 
    oprot.writeStructBegin('savePaymentSettlements_args')
23360 
    if self.settlementDate is not None:
23361 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23362 
      oprot.writeI64(self.settlementDate)
23363 
      oprot.writeFieldEnd()
23364 
    if self.paymentGatewayId is not None:
23365 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23366 
      oprot.writeI64(self.paymentGatewayId)
23367 
      oprot.writeFieldEnd()
4905 varun.gupt 23368 
    if self.referenceId is not None:
23369 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23370 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23371 
      oprot.writeFieldEnd()
23372 
    if self.serviceTax is not None:
23373 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23374 
      oprot.writeDouble(self.serviceTax)
23375 
      oprot.writeFieldEnd()
23376 
    if self.otherCharges is not None:
23377 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23378 
      oprot.writeDouble(self.otherCharges)
23379 
      oprot.writeFieldEnd()
23380 
    if self.netCollection is not None:
23381 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23382 
      oprot.writeDouble(self.netCollection)
23383 
      oprot.writeFieldEnd()
23384 
    oprot.writeFieldStop()
23385 
    oprot.writeStructEnd()
23386 
 
23387 
  def validate(self):
23388 
    return
23389 
 
23390 
 
23391 
  def __repr__(self):
23392 
    L = ['%s=%r' % (key, value)
23393 
      for key, value in self.__dict__.iteritems()]
23394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23395 
 
23396 
  def __eq__(self, other):
23397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23398 
 
23399 
  def __ne__(self, other):
23400 
    return not (self == other)
23401 
 
23402 
class savePaymentSettlements_result:
23403 
  """
23404 
  Attributes:
23405 
   - ex
23406 
  """
23407 
 
23408 
  thrift_spec = (
23409 
    None, # 0
23410 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23411 
  )
23412 
 
23413 
  def __init__(self, ex=None,):
23414 
    self.ex = ex
23415 
 
23416 
  def read(self, iprot):
23417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23419 
      return
23420 
    iprot.readStructBegin()
23421 
    while True:
23422 
      (fname, ftype, fid) = iprot.readFieldBegin()
23423 
      if ftype == TType.STOP:
23424 
        break
23425 
      if fid == 1:
23426 
        if ftype == TType.STRUCT:
23427 
          self.ex = TransactionServiceException()
23428 
          self.ex.read(iprot)
23429 
        else:
23430 
          iprot.skip(ftype)
23431 
      else:
23432 
        iprot.skip(ftype)
23433 
      iprot.readFieldEnd()
23434 
    iprot.readStructEnd()
23435 
 
23436 
  def write(self, oprot):
23437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23439 
      return
23440 
    oprot.writeStructBegin('savePaymentSettlements_result')
23441 
    if self.ex is not None:
23442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23443 
      self.ex.write(oprot)
23444 
      oprot.writeFieldEnd()
23445 
    oprot.writeFieldStop()
23446 
    oprot.writeStructEnd()
23447 
 
23448 
  def validate(self):
23449 
    return
23450 
 
23451 
 
23452 
  def __repr__(self):
23453 
    L = ['%s=%r' % (key, value)
23454 
      for key, value in self.__dict__.iteritems()]
23455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23456 
 
23457 
  def __eq__(self, other):
23458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23459 
 
23460 
  def __ne__(self, other):
23461 
    return not (self == other)
23462 
 
23463 
class saveEBSSettlementSummary_args:
23464 
  """
23465 
  Attributes:
23466 
   - settlementId
23467 
   - settlementDate
23468 
   - transactionDateFrom
23469 
   - transactionDateTo
23470 
   - amount
23471 
  """
23472 
 
23473 
  thrift_spec = (
23474 
    None, # 0
23475 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23476 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23477 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23478 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23479 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23480 
  )
23481 
 
23482 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23483 
    self.settlementId = settlementId
23484 
    self.settlementDate = settlementDate
23485 
    self.transactionDateFrom = transactionDateFrom
23486 
    self.transactionDateTo = transactionDateTo
23487 
    self.amount = amount
23488 
 
23489 
  def read(self, iprot):
23490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23492 
      return
23493 
    iprot.readStructBegin()
23494 
    while True:
23495 
      (fname, ftype, fid) = iprot.readFieldBegin()
23496 
      if ftype == TType.STOP:
23497 
        break
23498 
      if fid == 1:
23499 
        if ftype == TType.I64:
23500 
          self.settlementId = iprot.readI64();
23501 
        else:
23502 
          iprot.skip(ftype)
23503 
      elif fid == 2:
23504 
        if ftype == TType.I64:
23505 
          self.settlementDate = iprot.readI64();
23506 
        else:
23507 
          iprot.skip(ftype)
23508 
      elif fid == 3:
23509 
        if ftype == TType.I64:
23510 
          self.transactionDateFrom = iprot.readI64();
23511 
        else:
23512 
          iprot.skip(ftype)
23513 
      elif fid == 4:
23514 
        if ftype == TType.I64:
23515 
          self.transactionDateTo = iprot.readI64();
23516 
        else:
23517 
          iprot.skip(ftype)
23518 
      elif fid == 5:
23519 
        if ftype == TType.DOUBLE:
23520 
          self.amount = iprot.readDouble();
23521 
        else:
23522 
          iprot.skip(ftype)
23523 
      else:
23524 
        iprot.skip(ftype)
23525 
      iprot.readFieldEnd()
23526 
    iprot.readStructEnd()
23527 
 
23528 
  def write(self, oprot):
23529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23531 
      return
23532 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23533 
    if self.settlementId is not None:
23534 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23535 
      oprot.writeI64(self.settlementId)
23536 
      oprot.writeFieldEnd()
23537 
    if self.settlementDate is not None:
23538 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23539 
      oprot.writeI64(self.settlementDate)
23540 
      oprot.writeFieldEnd()
23541 
    if self.transactionDateFrom is not None:
23542 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23543 
      oprot.writeI64(self.transactionDateFrom)
23544 
      oprot.writeFieldEnd()
23545 
    if self.transactionDateTo is not None:
23546 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23547 
      oprot.writeI64(self.transactionDateTo)
23548 
      oprot.writeFieldEnd()
23549 
    if self.amount is not None:
23550 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23551 
      oprot.writeDouble(self.amount)
23552 
      oprot.writeFieldEnd()
23553 
    oprot.writeFieldStop()
23554 
    oprot.writeStructEnd()
23555 
 
23556 
  def validate(self):
23557 
    return
23558 
 
23559 
 
23560 
  def __repr__(self):
23561 
    L = ['%s=%r' % (key, value)
23562 
      for key, value in self.__dict__.iteritems()]
23563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23564 
 
23565 
  def __eq__(self, other):
23566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23567 
 
23568 
  def __ne__(self, other):
23569 
    return not (self == other)
23570 
 
23571 
class saveEBSSettlementSummary_result:
23572 
  """
23573 
  Attributes:
23574 
   - ex
23575 
  """
23576 
 
23577 
  thrift_spec = (
23578 
    None, # 0
23579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23580 
  )
23581 
 
23582 
  def __init__(self, ex=None,):
23583 
    self.ex = ex
23584 
 
23585 
  def read(self, iprot):
23586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23588 
      return
23589 
    iprot.readStructBegin()
23590 
    while True:
23591 
      (fname, ftype, fid) = iprot.readFieldBegin()
23592 
      if ftype == TType.STOP:
23593 
        break
23594 
      if fid == 1:
23595 
        if ftype == TType.STRUCT:
23596 
          self.ex = TransactionServiceException()
23597 
          self.ex.read(iprot)
23598 
        else:
23599 
          iprot.skip(ftype)
23600 
      else:
23601 
        iprot.skip(ftype)
23602 
      iprot.readFieldEnd()
23603 
    iprot.readStructEnd()
23604 
 
23605 
  def write(self, oprot):
23606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23608 
      return
23609 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23610 
    if self.ex is not None:
23611 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23612 
      self.ex.write(oprot)
23613 
      oprot.writeFieldEnd()
23614 
    oprot.writeFieldStop()
23615 
    oprot.writeStructEnd()
23616 
 
23617 
  def validate(self):
23618 
    return
23619 
 
23620 
 
23621 
  def __repr__(self):
23622 
    L = ['%s=%r' % (key, value)
23623 
      for key, value in self.__dict__.iteritems()]
23624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23625 
 
23626 
  def __eq__(self, other):
23627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23628 
 
23629 
  def __ne__(self, other):
23630 
    return not (self == other)
23631 
 
5386 phani.kuma 23632 
class getSettlementForPrepaid_args:
4600 varun.gupt 23633 
  """
23634 
  Attributes:
5189 varun.gupt 23635 
   - referenceId
23636 
   - isRefund
4600 varun.gupt 23637 
  """
23638 
 
23639 
  thrift_spec = (
23640 
    None, # 0
5189 varun.gupt 23641 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23642 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23643 
  )
23644 
 
5386 phani.kuma 23645 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23646 
    self.referenceId = referenceId
23647 
    self.isRefund = isRefund
4600 varun.gupt 23648 
 
23649 
  def read(self, iprot):
23650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23652 
      return
23653 
    iprot.readStructBegin()
23654 
    while True:
23655 
      (fname, ftype, fid) = iprot.readFieldBegin()
23656 
      if ftype == TType.STOP:
23657 
        break
23658 
      if fid == 1:
23659 
        if ftype == TType.I64:
5189 varun.gupt 23660 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23661 
        else:
23662 
          iprot.skip(ftype)
5189 varun.gupt 23663 
      elif fid == 2:
23664 
        if ftype == TType.BOOL:
23665 
          self.isRefund = iprot.readBool();
23666 
        else:
23667 
          iprot.skip(ftype)
4600 varun.gupt 23668 
      else:
23669 
        iprot.skip(ftype)
23670 
      iprot.readFieldEnd()
23671 
    iprot.readStructEnd()
23672 
 
23673 
  def write(self, oprot):
23674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23676 
      return
5386 phani.kuma 23677 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23678 
    if self.referenceId is not None:
23679 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23680 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23681 
      oprot.writeFieldEnd()
5386 phani.kuma 23682 
    if self.isRefund is not None:
23683 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23684 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23685 
      oprot.writeFieldEnd()
5386 phani.kuma 23686 
    oprot.writeFieldStop()
23687 
    oprot.writeStructEnd()
23688 
 
23689 
  def validate(self):
23690 
    return
23691 
 
23692 
 
23693 
  def __repr__(self):
23694 
    L = ['%s=%r' % (key, value)
23695 
      for key, value in self.__dict__.iteritems()]
23696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23697 
 
23698 
  def __eq__(self, other):
23699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23700 
 
23701 
  def __ne__(self, other):
23702 
    return not (self == other)
23703 
 
23704 
class getSettlementForPrepaid_result:
23705 
  """
23706 
  Attributes:
23707 
   - success
23708 
   - ex
23709 
  """
23710 
 
23711 
  thrift_spec = (
23712 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23714 
  )
23715 
 
23716 
  def __init__(self, success=None, ex=None,):
23717 
    self.success = success
23718 
    self.ex = ex
23719 
 
23720 
  def read(self, iprot):
23721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23723 
      return
23724 
    iprot.readStructBegin()
23725 
    while True:
23726 
      (fname, ftype, fid) = iprot.readFieldBegin()
23727 
      if ftype == TType.STOP:
23728 
        break
23729 
      if fid == 0:
23730 
        if ftype == TType.STRUCT:
23731 
          self.success = PaymentSettlement()
23732 
          self.success.read(iprot)
23733 
        else:
23734 
          iprot.skip(ftype)
23735 
      elif fid == 1:
23736 
        if ftype == TType.STRUCT:
23737 
          self.ex = TransactionServiceException()
23738 
          self.ex.read(iprot)
23739 
        else:
23740 
          iprot.skip(ftype)
23741 
      else:
23742 
        iprot.skip(ftype)
23743 
      iprot.readFieldEnd()
23744 
    iprot.readStructEnd()
23745 
 
23746 
  def write(self, oprot):
23747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23749 
      return
23750 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23751 
    if self.success is not None:
23752 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23753 
      self.success.write(oprot)
23754 
      oprot.writeFieldEnd()
23755 
    if self.ex is not None:
23756 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23757 
      self.ex.write(oprot)
23758 
      oprot.writeFieldEnd()
23759 
    oprot.writeFieldStop()
23760 
    oprot.writeStructEnd()
23761 
 
23762 
  def validate(self):
23763 
    return
23764 
 
23765 
 
23766 
  def __repr__(self):
23767 
    L = ['%s=%r' % (key, value)
23768 
      for key, value in self.__dict__.iteritems()]
23769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23770 
 
23771 
  def __eq__(self, other):
23772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23773 
 
23774 
  def __ne__(self, other):
23775 
    return not (self == other)
23776 
 
23777 
class getSettlementForCod_args:
23778 
  """
23779 
  Attributes:
23780 
   - orderId
23781 
   - isRefund
23782 
  """
23783 
 
23784 
  thrift_spec = (
23785 
    None, # 0
23786 
    (1, TType.I64, 'orderId', None, None, ), # 1
23787 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23788 
  )
23789 
 
23790 
  def __init__(self, orderId=None, isRefund=None,):
23791 
    self.orderId = orderId
23792 
    self.isRefund = isRefund
23793 
 
23794 
  def read(self, iprot):
23795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23797 
      return
23798 
    iprot.readStructBegin()
23799 
    while True:
23800 
      (fname, ftype, fid) = iprot.readFieldBegin()
23801 
      if ftype == TType.STOP:
23802 
        break
23803 
      if fid == 1:
23804 
        if ftype == TType.I64:
23805 
          self.orderId = iprot.readI64();
23806 
        else:
23807 
          iprot.skip(ftype)
23808 
      elif fid == 2:
23809 
        if ftype == TType.BOOL:
23810 
          self.isRefund = iprot.readBool();
23811 
        else:
23812 
          iprot.skip(ftype)
23813 
      else:
23814 
        iprot.skip(ftype)
23815 
      iprot.readFieldEnd()
23816 
    iprot.readStructEnd()
23817 
 
23818 
  def write(self, oprot):
23819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23821 
      return
23822 
    oprot.writeStructBegin('getSettlementForCod_args')
23823 
    if self.orderId is not None:
23824 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23825 
      oprot.writeI64(self.orderId)
23826 
      oprot.writeFieldEnd()
5189 varun.gupt 23827 
    if self.isRefund is not None:
5386 phani.kuma 23828 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23829 
      oprot.writeBool(self.isRefund)
23830 
      oprot.writeFieldEnd()
4600 varun.gupt 23831 
    oprot.writeFieldStop()
23832 
    oprot.writeStructEnd()
23833 
 
23834 
  def validate(self):
23835 
    return
23836 
 
23837 
 
23838 
  def __repr__(self):
23839 
    L = ['%s=%r' % (key, value)
23840 
      for key, value in self.__dict__.iteritems()]
23841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23842 
 
23843 
  def __eq__(self, other):
23844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23845 
 
23846 
  def __ne__(self, other):
23847 
    return not (self == other)
23848 
 
5386 phani.kuma 23849 
class getSettlementForCod_result:
4600 varun.gupt 23850 
  """
23851 
  Attributes:
23852 
   - success
23853 
   - ex
23854 
  """
23855 
 
23856 
  thrift_spec = (
23857 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23859 
  )
23860 
 
23861 
  def __init__(self, success=None, ex=None,):
23862 
    self.success = success
23863 
    self.ex = ex
23864 
 
23865 
  def read(self, iprot):
23866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23868 
      return
23869 
    iprot.readStructBegin()
23870 
    while True:
23871 
      (fname, ftype, fid) = iprot.readFieldBegin()
23872 
      if ftype == TType.STOP:
23873 
        break
23874 
      if fid == 0:
23875 
        if ftype == TType.STRUCT:
23876 
          self.success = PaymentSettlement()
23877 
          self.success.read(iprot)
23878 
        else:
23879 
          iprot.skip(ftype)
23880 
      elif fid == 1:
23881 
        if ftype == TType.STRUCT:
23882 
          self.ex = TransactionServiceException()
23883 
          self.ex.read(iprot)
23884 
        else:
23885 
          iprot.skip(ftype)
23886 
      else:
23887 
        iprot.skip(ftype)
23888 
      iprot.readFieldEnd()
23889 
    iprot.readStructEnd()
23890 
 
23891 
  def write(self, oprot):
23892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23894 
      return
5386 phani.kuma 23895 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23896 
    if self.success is not None:
23897 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23898 
      self.success.write(oprot)
23899 
      oprot.writeFieldEnd()
23900 
    if self.ex is not None:
23901 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23902 
      self.ex.write(oprot)
23903 
      oprot.writeFieldEnd()
23904 
    oprot.writeFieldStop()
23905 
    oprot.writeStructEnd()
23906 
 
23907 
  def validate(self):
23908 
    return
23909 
 
23910 
 
23911 
  def __repr__(self):
23912 
    L = ['%s=%r' % (key, value)
23913 
      for key, value in self.__dict__.iteritems()]
23914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23915 
 
23916 
  def __eq__(self, other):
23917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23918 
 
23919 
  def __ne__(self, other):
23920 
    return not (self == other)
23921 
 
23922 
class getEBSSettlementSummaries_args:
23923 
 
23924 
  thrift_spec = (
23925 
  )
23926 
 
23927 
  def read(self, iprot):
23928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23930 
      return
23931 
    iprot.readStructBegin()
23932 
    while True:
23933 
      (fname, ftype, fid) = iprot.readFieldBegin()
23934 
      if ftype == TType.STOP:
23935 
        break
23936 
      else:
23937 
        iprot.skip(ftype)
23938 
      iprot.readFieldEnd()
23939 
    iprot.readStructEnd()
23940 
 
23941 
  def write(self, oprot):
23942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23944 
      return
23945 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23946 
    oprot.writeFieldStop()
23947 
    oprot.writeStructEnd()
23948 
 
23949 
  def validate(self):
23950 
    return
23951 
 
23952 
 
23953 
  def __repr__(self):
23954 
    L = ['%s=%r' % (key, value)
23955 
      for key, value in self.__dict__.iteritems()]
23956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23957 
 
23958 
  def __eq__(self, other):
23959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23960 
 
23961 
  def __ne__(self, other):
23962 
    return not (self == other)
23963 
 
23964 
class getEBSSettlementSummaries_result:
23965 
  """
23966 
  Attributes:
23967 
   - success
23968 
   - ex
23969 
  """
23970 
 
23971 
  thrift_spec = (
23972 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23974 
  )
23975 
 
23976 
  def __init__(self, success=None, ex=None,):
23977 
    self.success = success
23978 
    self.ex = ex
23979 
 
23980 
  def read(self, iprot):
23981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23983 
      return
23984 
    iprot.readStructBegin()
23985 
    while True:
23986 
      (fname, ftype, fid) = iprot.readFieldBegin()
23987 
      if ftype == TType.STOP:
23988 
        break
23989 
      if fid == 0:
23990 
        if ftype == TType.MAP:
23991 
          self.success = {}
6188 rajveer 23992 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23993 
          for _i558 in xrange(_size554):
23994 
            _key559 = iprot.readI64();
23995 
            _val560 = iprot.readString();
23996 
            self.success[_key559] = _val560
4600 varun.gupt 23997 
          iprot.readMapEnd()
23998 
        else:
23999 
          iprot.skip(ftype)
24000 
      elif fid == 1:
24001 
        if ftype == TType.STRUCT:
24002 
          self.ex = TransactionServiceException()
24003 
          self.ex.read(iprot)
24004 
        else:
24005 
          iprot.skip(ftype)
24006 
      else:
24007 
        iprot.skip(ftype)
24008 
      iprot.readFieldEnd()
24009 
    iprot.readStructEnd()
24010 
 
24011 
  def write(self, oprot):
24012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24014 
      return
24015 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24016 
    if self.success is not None:
24017 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24018 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24019 
      for kiter561,viter562 in self.success.items():
24020 
        oprot.writeI64(kiter561)
24021 
        oprot.writeString(viter562)
4600 varun.gupt 24022 
      oprot.writeMapEnd()
24023 
      oprot.writeFieldEnd()
24024 
    if self.ex is not None:
24025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24026 
      self.ex.write(oprot)
24027 
      oprot.writeFieldEnd()
24028 
    oprot.writeFieldStop()
24029 
    oprot.writeStructEnd()
24030 
 
24031 
  def validate(self):
24032 
    return
24033 
 
24034 
 
24035 
  def __repr__(self):
24036 
    L = ['%s=%r' % (key, value)
24037 
      for key, value in self.__dict__.iteritems()]
24038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24039 
 
24040 
  def __eq__(self, other):
24041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24042 
 
24043 
  def __ne__(self, other):
24044 
    return not (self == other)
24045 
 
24046 
class markEBSSettlementUploaded_args:
24047 
  """
24048 
  Attributes:
24049 
   - settlementId
24050 
  """
24051 
 
24052 
  thrift_spec = (
24053 
    None, # 0
24054 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24055 
  )
24056 
 
24057 
  def __init__(self, settlementId=None,):
24058 
    self.settlementId = settlementId
24059 
 
24060 
  def read(self, iprot):
24061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24063 
      return
24064 
    iprot.readStructBegin()
24065 
    while True:
24066 
      (fname, ftype, fid) = iprot.readFieldBegin()
24067 
      if ftype == TType.STOP:
24068 
        break
24069 
      if fid == 1:
24070 
        if ftype == TType.I64:
24071 
          self.settlementId = iprot.readI64();
24072 
        else:
24073 
          iprot.skip(ftype)
24074 
      else:
24075 
        iprot.skip(ftype)
24076 
      iprot.readFieldEnd()
24077 
    iprot.readStructEnd()
24078 
 
24079 
  def write(self, oprot):
24080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24082 
      return
24083 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24084 
    if self.settlementId is not None:
24085 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24086 
      oprot.writeI64(self.settlementId)
24087 
      oprot.writeFieldEnd()
24088 
    oprot.writeFieldStop()
24089 
    oprot.writeStructEnd()
24090 
 
24091 
  def validate(self):
24092 
    return
24093 
 
24094 
 
24095 
  def __repr__(self):
24096 
    L = ['%s=%r' % (key, value)
24097 
      for key, value in self.__dict__.iteritems()]
24098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24099 
 
24100 
  def __eq__(self, other):
24101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24102 
 
24103 
  def __ne__(self, other):
24104 
    return not (self == other)
24105 
 
24106 
class markEBSSettlementUploaded_result:
24107 
  """
24108 
  Attributes:
24109 
   - ex
24110 
  """
24111 
 
24112 
  thrift_spec = (
24113 
    None, # 0
24114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24115 
  )
24116 
 
24117 
  def __init__(self, ex=None,):
24118 
    self.ex = ex
24119 
 
24120 
  def read(self, iprot):
24121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24123 
      return
24124 
    iprot.readStructBegin()
24125 
    while True:
24126 
      (fname, ftype, fid) = iprot.readFieldBegin()
24127 
      if ftype == TType.STOP:
24128 
        break
24129 
      if fid == 1:
24130 
        if ftype == TType.STRUCT:
24131 
          self.ex = TransactionServiceException()
24132 
          self.ex.read(iprot)
24133 
        else:
24134 
          iprot.skip(ftype)
24135 
      else:
24136 
        iprot.skip(ftype)
24137 
      iprot.readFieldEnd()
24138 
    iprot.readStructEnd()
24139 
 
24140 
  def write(self, oprot):
24141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24143 
      return
24144 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24145 
    if self.ex is not None:
24146 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24147 
      self.ex.write(oprot)
24148 
      oprot.writeFieldEnd()
24149 
    oprot.writeFieldStop()
24150 
    oprot.writeStructEnd()
24151 
 
24152 
  def validate(self):
24153 
    return
24154 
 
24155 
 
24156 
  def __repr__(self):
24157 
    L = ['%s=%r' % (key, value)
24158 
      for key, value in self.__dict__.iteritems()]
24159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24160 
 
24161 
  def __eq__(self, other):
24162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24163 
 
24164 
  def __ne__(self, other):
24165 
    return not (self == other)
24166 
 
24167 
class getEBSSettlementDate_args:
24168 
  """
24169 
  Attributes:
24170 
   - settlementId
24171 
  """
24172 
 
24173 
  thrift_spec = (
24174 
    None, # 0
24175 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24176 
  )
24177 
 
24178 
  def __init__(self, settlementId=None,):
24179 
    self.settlementId = settlementId
24180 
 
24181 
  def read(self, iprot):
24182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24184 
      return
24185 
    iprot.readStructBegin()
24186 
    while True:
24187 
      (fname, ftype, fid) = iprot.readFieldBegin()
24188 
      if ftype == TType.STOP:
24189 
        break
24190 
      if fid == 1:
24191 
        if ftype == TType.I64:
24192 
          self.settlementId = iprot.readI64();
24193 
        else:
24194 
          iprot.skip(ftype)
24195 
      else:
24196 
        iprot.skip(ftype)
24197 
      iprot.readFieldEnd()
24198 
    iprot.readStructEnd()
24199 
 
24200 
  def write(self, oprot):
24201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24203 
      return
24204 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24205 
    if self.settlementId is not None:
24206 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24207 
      oprot.writeI64(self.settlementId)
24208 
      oprot.writeFieldEnd()
24209 
    oprot.writeFieldStop()
24210 
    oprot.writeStructEnd()
24211 
 
24212 
  def validate(self):
24213 
    return
24214 
 
24215 
 
24216 
  def __repr__(self):
24217 
    L = ['%s=%r' % (key, value)
24218 
      for key, value in self.__dict__.iteritems()]
24219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24220 
 
24221 
  def __eq__(self, other):
24222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24223 
 
24224 
  def __ne__(self, other):
24225 
    return not (self == other)
24226 
 
24227 
class getEBSSettlementDate_result:
24228 
  """
24229 
  Attributes:
24230 
   - success
24231 
   - ex
24232 
  """
24233 
 
24234 
  thrift_spec = (
24235 
    (0, TType.I64, 'success', None, None, ), # 0
24236 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24237 
  )
24238 
 
24239 
  def __init__(self, success=None, ex=None,):
24240 
    self.success = success
24241 
    self.ex = ex
24242 
 
24243 
  def read(self, iprot):
24244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24246 
      return
24247 
    iprot.readStructBegin()
24248 
    while True:
24249 
      (fname, ftype, fid) = iprot.readFieldBegin()
24250 
      if ftype == TType.STOP:
24251 
        break
24252 
      if fid == 0:
24253 
        if ftype == TType.I64:
24254 
          self.success = iprot.readI64();
24255 
        else:
24256 
          iprot.skip(ftype)
24257 
      elif fid == 1:
24258 
        if ftype == TType.STRUCT:
24259 
          self.ex = TransactionServiceException()
24260 
          self.ex.read(iprot)
24261 
        else:
24262 
          iprot.skip(ftype)
24263 
      else:
24264 
        iprot.skip(ftype)
24265 
      iprot.readFieldEnd()
24266 
    iprot.readStructEnd()
24267 
 
24268 
  def write(self, oprot):
24269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24271 
      return
24272 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24273 
    if self.success is not None:
24274 
      oprot.writeFieldBegin('success', TType.I64, 0)
24275 
      oprot.writeI64(self.success)
24276 
      oprot.writeFieldEnd()
24277 
    if self.ex is not None:
24278 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24279 
      self.ex.write(oprot)
24280 
      oprot.writeFieldEnd()
24281 
    oprot.writeFieldStop()
24282 
    oprot.writeStructEnd()
24283 
 
24284 
  def validate(self):
24285 
    return
24286 
 
24287 
 
24288 
  def __repr__(self):
24289 
    L = ['%s=%r' % (key, value)
24290 
      for key, value in self.__dict__.iteritems()]
24291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24292 
 
24293 
  def __eq__(self, other):
24294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24295 
 
24296 
  def __ne__(self, other):
24297 
    return not (self == other)
4715 varun.gupt 24298 
 
24299 
class getSettlementsByDate_args:
24300 
  """
24301 
  Attributes:
24302 
   - settlementDateFrom
24303 
   - settlementDateTo
24304 
   - isRefund
24305 
  """
24306 
 
24307 
  thrift_spec = (
24308 
    None, # 0
24309 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24310 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24311 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24312 
  )
24313 
 
24314 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24315 
    self.settlementDateFrom = settlementDateFrom
24316 
    self.settlementDateTo = settlementDateTo
24317 
    self.isRefund = isRefund
24318 
 
24319 
  def read(self, iprot):
24320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24322 
      return
24323 
    iprot.readStructBegin()
24324 
    while True:
24325 
      (fname, ftype, fid) = iprot.readFieldBegin()
24326 
      if ftype == TType.STOP:
24327 
        break
24328 
      if fid == 1:
24329 
        if ftype == TType.I64:
24330 
          self.settlementDateFrom = iprot.readI64();
24331 
        else:
24332 
          iprot.skip(ftype)
24333 
      elif fid == 2:
24334 
        if ftype == TType.I64:
24335 
          self.settlementDateTo = iprot.readI64();
24336 
        else:
24337 
          iprot.skip(ftype)
24338 
      elif fid == 3:
24339 
        if ftype == TType.BOOL:
24340 
          self.isRefund = iprot.readBool();
24341 
        else:
24342 
          iprot.skip(ftype)
24343 
      else:
24344 
        iprot.skip(ftype)
24345 
      iprot.readFieldEnd()
24346 
    iprot.readStructEnd()
24347 
 
24348 
  def write(self, oprot):
24349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24351 
      return
24352 
    oprot.writeStructBegin('getSettlementsByDate_args')
24353 
    if self.settlementDateFrom is not None:
24354 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24355 
      oprot.writeI64(self.settlementDateFrom)
24356 
      oprot.writeFieldEnd()
24357 
    if self.settlementDateTo is not None:
24358 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24359 
      oprot.writeI64(self.settlementDateTo)
24360 
      oprot.writeFieldEnd()
24361 
    if self.isRefund is not None:
24362 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24363 
      oprot.writeBool(self.isRefund)
24364 
      oprot.writeFieldEnd()
24365 
    oprot.writeFieldStop()
24366 
    oprot.writeStructEnd()
24367 
 
24368 
  def validate(self):
24369 
    return
24370 
 
24371 
 
24372 
  def __repr__(self):
24373 
    L = ['%s=%r' % (key, value)
24374 
      for key, value in self.__dict__.iteritems()]
24375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24376 
 
24377 
  def __eq__(self, other):
24378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24379 
 
24380 
  def __ne__(self, other):
24381 
    return not (self == other)
24382 
 
24383 
class getSettlementsByDate_result:
24384 
  """
24385 
  Attributes:
24386 
   - success
24387 
   - ex
24388 
  """
24389 
 
24390 
  thrift_spec = (
24391 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24392 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24393 
  )
24394 
 
24395 
  def __init__(self, success=None, ex=None,):
24396 
    self.success = success
24397 
    self.ex = ex
24398 
 
24399 
  def read(self, iprot):
24400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24402 
      return
24403 
    iprot.readStructBegin()
24404 
    while True:
24405 
      (fname, ftype, fid) = iprot.readFieldBegin()
24406 
      if ftype == TType.STOP:
24407 
        break
24408 
      if fid == 0:
24409 
        if ftype == TType.LIST:
24410 
          self.success = []
6188 rajveer 24411 
          (_etype566, _size563) = iprot.readListBegin()
24412 
          for _i567 in xrange(_size563):
24413 
            _elem568 = PaymentSettlement()
24414 
            _elem568.read(iprot)
24415 
            self.success.append(_elem568)
4715 varun.gupt 24416 
          iprot.readListEnd()
24417 
        else:
24418 
          iprot.skip(ftype)
24419 
      elif fid == 1:
24420 
        if ftype == TType.STRUCT:
24421 
          self.ex = TransactionServiceException()
24422 
          self.ex.read(iprot)
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('getSettlementsByDate_result')
24435 
    if self.success is not None:
24436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24438 
      for iter569 in self.success:
24439 
        iter569.write(oprot)
4715 varun.gupt 24440 
      oprot.writeListEnd()
24441 
      oprot.writeFieldEnd()
24442 
    if self.ex is not None:
24443 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24444 
      self.ex.write(oprot)
24445 
      oprot.writeFieldEnd()
24446 
    oprot.writeFieldStop()
24447 
    oprot.writeStructEnd()
24448 
 
24449 
  def validate(self):
24450 
    return
24451 
 
24452 
 
24453 
  def __repr__(self):
24454 
    L = ['%s=%r' % (key, value)
24455 
      for key, value in self.__dict__.iteritems()]
24456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24457 
 
24458 
  def __eq__(self, other):
24459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24460 
 
24461 
  def __ne__(self, other):
24462 
    return not (self == other)
24463 
 
24464 
class getReshippedOrderIds_args:
24465 
  """
24466 
  Attributes:
24467 
   - orderIds
24468 
  """
24469 
 
24470 
  thrift_spec = (
24471 
    None, # 0
24472 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24473 
  )
24474 
 
24475 
  def __init__(self, orderIds=None,):
24476 
    self.orderIds = orderIds
24477 
 
24478 
  def read(self, iprot):
24479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24481 
      return
24482 
    iprot.readStructBegin()
24483 
    while True:
24484 
      (fname, ftype, fid) = iprot.readFieldBegin()
24485 
      if ftype == TType.STOP:
24486 
        break
24487 
      if fid == 1:
24488 
        if ftype == TType.LIST:
24489 
          self.orderIds = []
6188 rajveer 24490 
          (_etype573, _size570) = iprot.readListBegin()
24491 
          for _i574 in xrange(_size570):
24492 
            _elem575 = iprot.readI64();
24493 
            self.orderIds.append(_elem575)
4715 varun.gupt 24494 
          iprot.readListEnd()
24495 
        else:
24496 
          iprot.skip(ftype)
24497 
      else:
24498 
        iprot.skip(ftype)
24499 
      iprot.readFieldEnd()
24500 
    iprot.readStructEnd()
24501 
 
24502 
  def write(self, oprot):
24503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24505 
      return
24506 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24507 
    if self.orderIds is not None:
24508 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24509 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24510 
      for iter576 in self.orderIds:
24511 
        oprot.writeI64(iter576)
4715 varun.gupt 24512 
      oprot.writeListEnd()
24513 
      oprot.writeFieldEnd()
24514 
    oprot.writeFieldStop()
24515 
    oprot.writeStructEnd()
24516 
 
24517 
  def validate(self):
24518 
    return
24519 
 
24520 
 
24521 
  def __repr__(self):
24522 
    L = ['%s=%r' % (key, value)
24523 
      for key, value in self.__dict__.iteritems()]
24524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24525 
 
24526 
  def __eq__(self, other):
24527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24528 
 
24529 
  def __ne__(self, other):
24530 
    return not (self == other)
24531 
 
24532 
class getReshippedOrderIds_result:
24533 
  """
24534 
  Attributes:
24535 
   - success
24536 
   - ex
24537 
  """
24538 
 
24539 
  thrift_spec = (
24540 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24541 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24542 
  )
24543 
 
24544 
  def __init__(self, success=None, ex=None,):
24545 
    self.success = success
24546 
    self.ex = ex
24547 
 
24548 
  def read(self, iprot):
24549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24551 
      return
24552 
    iprot.readStructBegin()
24553 
    while True:
24554 
      (fname, ftype, fid) = iprot.readFieldBegin()
24555 
      if ftype == TType.STOP:
24556 
        break
24557 
      if fid == 0:
24558 
        if ftype == TType.LIST:
24559 
          self.success = []
6188 rajveer 24560 
          (_etype580, _size577) = iprot.readListBegin()
24561 
          for _i581 in xrange(_size577):
24562 
            _elem582 = iprot.readI64();
24563 
            self.success.append(_elem582)
4715 varun.gupt 24564 
          iprot.readListEnd()
24565 
        else:
24566 
          iprot.skip(ftype)
24567 
      elif fid == 1:
24568 
        if ftype == TType.STRUCT:
24569 
          self.ex = TransactionServiceException()
24570 
          self.ex.read(iprot)
24571 
        else:
24572 
          iprot.skip(ftype)
24573 
      else:
24574 
        iprot.skip(ftype)
24575 
      iprot.readFieldEnd()
24576 
    iprot.readStructEnd()
24577 
 
24578 
  def write(self, oprot):
24579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24581 
      return
24582 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24583 
    if self.success is not None:
24584 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24585 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24586 
      for iter583 in self.success:
24587 
        oprot.writeI64(iter583)
4715 varun.gupt 24588 
      oprot.writeListEnd()
24589 
      oprot.writeFieldEnd()
24590 
    if self.ex is not None:
24591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24592 
      self.ex.write(oprot)
24593 
      oprot.writeFieldEnd()
24594 
    oprot.writeFieldStop()
24595 
    oprot.writeStructEnd()
24596 
 
24597 
  def validate(self):
24598 
    return
24599 
 
24600 
 
24601 
  def __repr__(self):
24602 
    L = ['%s=%r' % (key, value)
24603 
      for key, value in self.__dict__.iteritems()]
24604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24605 
 
24606 
  def __eq__(self, other):
24607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24608 
 
24609 
  def __ne__(self, other):
24610 
    return not (self == other)
4757 mandeep.dh 24611 
 
5481 phani.kuma 24612 
class getBilledOrders_args:
4875 varun.gupt 24613 
  """
24614 
  Attributes:
24615 
   - vendorId
5481 phani.kuma 24616 
   - onlyVendorNotPaid
24617 
   - billingDateFrom
24618 
   - billingDateTo
4875 varun.gupt 24619 
  """
24620 
 
24621 
  thrift_spec = (
24622 
    None, # 0
24623 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24624 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24625 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24626 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24627 
  )
24628 
 
5481 phani.kuma 24629 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24630 
    self.vendorId = vendorId
5481 phani.kuma 24631 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24632 
    self.billingDateFrom = billingDateFrom
24633 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24634 
 
24635 
  def read(self, iprot):
24636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24638 
      return
24639 
    iprot.readStructBegin()
24640 
    while True:
24641 
      (fname, ftype, fid) = iprot.readFieldBegin()
24642 
      if ftype == TType.STOP:
24643 
        break
24644 
      if fid == 1:
24645 
        if ftype == TType.I64:
24646 
          self.vendorId = iprot.readI64();
24647 
        else:
24648 
          iprot.skip(ftype)
5481 phani.kuma 24649 
      elif fid == 2:
24650 
        if ftype == TType.BOOL:
24651 
          self.onlyVendorNotPaid = iprot.readBool();
24652 
        else:
24653 
          iprot.skip(ftype)
24654 
      elif fid == 3:
24655 
        if ftype == TType.I64:
24656 
          self.billingDateFrom = iprot.readI64();
24657 
        else:
24658 
          iprot.skip(ftype)
24659 
      elif fid == 4:
24660 
        if ftype == TType.I64:
24661 
          self.billingDateTo = iprot.readI64();
24662 
        else:
24663 
          iprot.skip(ftype)
4875 varun.gupt 24664 
      else:
24665 
        iprot.skip(ftype)
24666 
      iprot.readFieldEnd()
24667 
    iprot.readStructEnd()
24668 
 
24669 
  def write(self, oprot):
24670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24672 
      return
5481 phani.kuma 24673 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24674 
    if self.vendorId is not None:
24675 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24676 
      oprot.writeI64(self.vendorId)
24677 
      oprot.writeFieldEnd()
5481 phani.kuma 24678 
    if self.onlyVendorNotPaid is not None:
24679 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24680 
      oprot.writeBool(self.onlyVendorNotPaid)
24681 
      oprot.writeFieldEnd()
24682 
    if self.billingDateFrom is not None:
24683 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24684 
      oprot.writeI64(self.billingDateFrom)
24685 
      oprot.writeFieldEnd()
24686 
    if self.billingDateTo is not None:
24687 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24688 
      oprot.writeI64(self.billingDateTo)
24689 
      oprot.writeFieldEnd()
4875 varun.gupt 24690 
    oprot.writeFieldStop()
24691 
    oprot.writeStructEnd()
24692 
 
24693 
  def validate(self):
24694 
    return
24695 
 
24696 
 
24697 
  def __repr__(self):
24698 
    L = ['%s=%r' % (key, value)
24699 
      for key, value in self.__dict__.iteritems()]
24700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24701 
 
24702 
  def __eq__(self, other):
24703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24704 
 
24705 
  def __ne__(self, other):
24706 
    return not (self == other)
24707 
 
5481 phani.kuma 24708 
class getBilledOrders_result:
4875 varun.gupt 24709 
  """
24710 
  Attributes:
24711 
   - success
24712 
   - ex
24713 
  """
24714 
 
24715 
  thrift_spec = (
24716 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24718 
  )
24719 
 
24720 
  def __init__(self, success=None, ex=None,):
24721 
    self.success = success
24722 
    self.ex = ex
24723 
 
24724 
  def read(self, iprot):
24725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24727 
      return
24728 
    iprot.readStructBegin()
24729 
    while True:
24730 
      (fname, ftype, fid) = iprot.readFieldBegin()
24731 
      if ftype == TType.STOP:
24732 
        break
24733 
      if fid == 0:
24734 
        if ftype == TType.LIST:
24735 
          self.success = []
6188 rajveer 24736 
          (_etype587, _size584) = iprot.readListBegin()
24737 
          for _i588 in xrange(_size584):
24738 
            _elem589 = Order()
24739 
            _elem589.read(iprot)
24740 
            self.success.append(_elem589)
4875 varun.gupt 24741 
          iprot.readListEnd()
24742 
        else:
24743 
          iprot.skip(ftype)
24744 
      elif fid == 1:
24745 
        if ftype == TType.STRUCT:
24746 
          self.ex = TransactionServiceException()
24747 
          self.ex.read(iprot)
24748 
        else:
24749 
          iprot.skip(ftype)
24750 
      else:
24751 
        iprot.skip(ftype)
24752 
      iprot.readFieldEnd()
24753 
    iprot.readStructEnd()
24754 
 
24755 
  def write(self, oprot):
24756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24758 
      return
5481 phani.kuma 24759 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24760 
    if self.success is not None:
24761 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24762 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24763 
      for iter590 in self.success:
24764 
        iter590.write(oprot)
4875 varun.gupt 24765 
      oprot.writeListEnd()
24766 
      oprot.writeFieldEnd()
24767 
    if self.ex is not None:
24768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24769 
      self.ex.write(oprot)
24770 
      oprot.writeFieldEnd()
24771 
    oprot.writeFieldStop()
24772 
    oprot.writeStructEnd()
24773 
 
24774 
  def validate(self):
24775 
    return
24776 
 
24777 
 
24778 
  def __repr__(self):
24779 
    L = ['%s=%r' % (key, value)
24780 
      for key, value in self.__dict__.iteritems()]
24781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24782 
 
24783 
  def __eq__(self, other):
24784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24785 
 
24786 
  def __ne__(self, other):
24787 
    return not (self == other)
5031 varun.gupt 24788 
 
24789 
class getStatusDistributionOfOrders_args:
24790 
  """
24791 
  Attributes:
24792 
   - startDate
24793 
   - endDate
24794 
  """
24795 
 
24796 
  thrift_spec = (
24797 
    None, # 0
24798 
    (1, TType.I64, 'startDate', None, None, ), # 1
24799 
    (2, TType.I64, 'endDate', None, None, ), # 2
24800 
  )
24801 
 
24802 
  def __init__(self, startDate=None, endDate=None,):
24803 
    self.startDate = startDate
24804 
    self.endDate = endDate
24805 
 
24806 
  def read(self, iprot):
24807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24809 
      return
24810 
    iprot.readStructBegin()
24811 
    while True:
24812 
      (fname, ftype, fid) = iprot.readFieldBegin()
24813 
      if ftype == TType.STOP:
24814 
        break
24815 
      if fid == 1:
24816 
        if ftype == TType.I64:
24817 
          self.startDate = iprot.readI64();
24818 
        else:
24819 
          iprot.skip(ftype)
24820 
      elif fid == 2:
24821 
        if ftype == TType.I64:
24822 
          self.endDate = iprot.readI64();
24823 
        else:
24824 
          iprot.skip(ftype)
24825 
      else:
24826 
        iprot.skip(ftype)
24827 
      iprot.readFieldEnd()
24828 
    iprot.readStructEnd()
24829 
 
24830 
  def write(self, oprot):
24831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24833 
      return
24834 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24835 
    if self.startDate is not None:
24836 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24837 
      oprot.writeI64(self.startDate)
24838 
      oprot.writeFieldEnd()
24839 
    if self.endDate is not None:
24840 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24841 
      oprot.writeI64(self.endDate)
24842 
      oprot.writeFieldEnd()
24843 
    oprot.writeFieldStop()
24844 
    oprot.writeStructEnd()
24845 
 
24846 
  def validate(self):
24847 
    return
24848 
 
24849 
 
24850 
  def __repr__(self):
24851 
    L = ['%s=%r' % (key, value)
24852 
      for key, value in self.__dict__.iteritems()]
24853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24854 
 
24855 
  def __eq__(self, other):
24856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24857 
 
24858 
  def __ne__(self, other):
24859 
    return not (self == other)
24860 
 
24861 
class getStatusDistributionOfOrders_result:
24862 
  """
24863 
  Attributes:
24864 
   - success
24865 
   - ex
24866 
  """
24867 
 
24868 
  thrift_spec = (
24869 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24870 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24871 
  )
24872 
 
24873 
  def __init__(self, success=None, ex=None,):
24874 
    self.success = success
24875 
    self.ex = ex
24876 
 
24877 
  def read(self, iprot):
24878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24880 
      return
24881 
    iprot.readStructBegin()
24882 
    while True:
24883 
      (fname, ftype, fid) = iprot.readFieldBegin()
24884 
      if ftype == TType.STOP:
24885 
        break
24886 
      if fid == 0:
24887 
        if ftype == TType.MAP:
24888 
          self.success = {}
6188 rajveer 24889 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24890 
          for _i595 in xrange(_size591):
24891 
            _key596 = iprot.readI64();
24892 
            _val597 = iprot.readI64();
24893 
            self.success[_key596] = _val597
5031 varun.gupt 24894 
          iprot.readMapEnd()
24895 
        else:
24896 
          iprot.skip(ftype)
24897 
      elif fid == 1:
24898 
        if ftype == TType.STRUCT:
24899 
          self.ex = TransactionServiceException()
24900 
          self.ex.read(iprot)
24901 
        else:
24902 
          iprot.skip(ftype)
24903 
      else:
24904 
        iprot.skip(ftype)
24905 
      iprot.readFieldEnd()
24906 
    iprot.readStructEnd()
24907 
 
24908 
  def write(self, oprot):
24909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24911 
      return
24912 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24913 
    if self.success is not None:
24914 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24915 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24916 
      for kiter598,viter599 in self.success.items():
24917 
        oprot.writeI64(kiter598)
24918 
        oprot.writeI64(viter599)
5031 varun.gupt 24919 
      oprot.writeMapEnd()
24920 
      oprot.writeFieldEnd()
24921 
    if self.ex is not None:
24922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24923 
      self.ex.write(oprot)
24924 
      oprot.writeFieldEnd()
24925 
    oprot.writeFieldStop()
24926 
    oprot.writeStructEnd()
24927 
 
24928 
  def validate(self):
24929 
    return
24930 
 
24931 
 
24932 
  def __repr__(self):
24933 
    L = ['%s=%r' % (key, value)
24934 
      for key, value in self.__dict__.iteritems()]
24935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24936 
 
24937 
  def __eq__(self, other):
24938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24939 
 
24940 
  def __ne__(self, other):
24941 
    return not (self == other)
5067 varun.gupt 24942 
 
24943 
class getOrderIdsForStatus_args:
24944 
  """
24945 
  Attributes:
24946 
   - status
24947 
   - startDatetime
24948 
   - endDatetime
24949 
  """
24950 
 
24951 
  thrift_spec = (
24952 
    None, # 0
24953 
    (1, TType.I64, 'status', None, None, ), # 1
24954 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24955 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24956 
  )
24957 
 
24958 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24959 
    self.status = status
24960 
    self.startDatetime = startDatetime
24961 
    self.endDatetime = endDatetime
24962 
 
24963 
  def read(self, iprot):
24964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24966 
      return
24967 
    iprot.readStructBegin()
24968 
    while True:
24969 
      (fname, ftype, fid) = iprot.readFieldBegin()
24970 
      if ftype == TType.STOP:
24971 
        break
24972 
      if fid == 1:
24973 
        if ftype == TType.I64:
24974 
          self.status = iprot.readI64();
24975 
        else:
24976 
          iprot.skip(ftype)
24977 
      elif fid == 2:
24978 
        if ftype == TType.I64:
24979 
          self.startDatetime = iprot.readI64();
24980 
        else:
24981 
          iprot.skip(ftype)
24982 
      elif fid == 3:
24983 
        if ftype == TType.I64:
24984 
          self.endDatetime = iprot.readI64();
24985 
        else:
24986 
          iprot.skip(ftype)
24987 
      else:
24988 
        iprot.skip(ftype)
24989 
      iprot.readFieldEnd()
24990 
    iprot.readStructEnd()
24991 
 
24992 
  def write(self, oprot):
24993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24995 
      return
24996 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24997 
    if self.status is not None:
24998 
      oprot.writeFieldBegin('status', TType.I64, 1)
24999 
      oprot.writeI64(self.status)
25000 
      oprot.writeFieldEnd()
25001 
    if self.startDatetime is not None:
25002 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25003 
      oprot.writeI64(self.startDatetime)
25004 
      oprot.writeFieldEnd()
25005 
    if self.endDatetime is not None:
25006 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25007 
      oprot.writeI64(self.endDatetime)
25008 
      oprot.writeFieldEnd()
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 
 
25027 
class getOrderIdsForStatus_result:
25028 
  """
25029 
  Attributes:
25030 
   - success
25031 
   - ex
25032 
  """
25033 
 
25034 
  thrift_spec = (
25035 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25037 
  )
25038 
 
25039 
  def __init__(self, success=None, ex=None,):
25040 
    self.success = success
25041 
    self.ex = ex
25042 
 
25043 
  def read(self, iprot):
25044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25046 
      return
25047 
    iprot.readStructBegin()
25048 
    while True:
25049 
      (fname, ftype, fid) = iprot.readFieldBegin()
25050 
      if ftype == TType.STOP:
25051 
        break
25052 
      if fid == 0:
25053 
        if ftype == TType.LIST:
25054 
          self.success = []
6188 rajveer 25055 
          (_etype603, _size600) = iprot.readListBegin()
25056 
          for _i604 in xrange(_size600):
25057 
            _elem605 = iprot.readI64();
25058 
            self.success.append(_elem605)
5067 varun.gupt 25059 
          iprot.readListEnd()
25060 
        else:
25061 
          iprot.skip(ftype)
25062 
      elif fid == 1:
25063 
        if ftype == TType.STRUCT:
25064 
          self.ex = TransactionServiceException()
25065 
          self.ex.read(iprot)
25066 
        else:
25067 
          iprot.skip(ftype)
25068 
      else:
25069 
        iprot.skip(ftype)
25070 
      iprot.readFieldEnd()
25071 
    iprot.readStructEnd()
25072 
 
25073 
  def write(self, oprot):
25074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25076 
      return
25077 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25078 
    if self.success is not None:
25079 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25080 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25081 
      for iter606 in self.success:
25082 
        oprot.writeI64(iter606)
5067 varun.gupt 25083 
      oprot.writeListEnd()
25084 
      oprot.writeFieldEnd()
25085 
    if self.ex is not None:
25086 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25087 
      self.ex.write(oprot)
25088 
      oprot.writeFieldEnd()
25089 
    oprot.writeFieldStop()
25090 
    oprot.writeStructEnd()
25091 
 
25092 
  def validate(self):
25093 
    return
25094 
 
25095 
 
25096 
  def __repr__(self):
25097 
    L = ['%s=%r' % (key, value)
25098 
      for key, value in self.__dict__.iteritems()]
25099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25100 
 
25101 
  def __eq__(self, other):
25102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25103 
 
25104 
  def __ne__(self, other):
25105 
    return not (self == other)
5099 varun.gupt 25106 
 
5348 anupam.sin 25107 
class updateCODAgent_args:
25108 
  """
25109 
  Attributes:
25110 
   - agent
25111 
   - orderId
25112 
  """
25113 
 
25114 
  thrift_spec = (
25115 
    None, # 0
25116 
    (1, TType.STRING, 'agent', None, None, ), # 1
25117 
    (2, TType.I64, 'orderId', None, None, ), # 2
25118 
  )
25119 
 
25120 
  def __init__(self, agent=None, orderId=None,):
25121 
    self.agent = agent
25122 
    self.orderId = orderId
25123 
 
25124 
  def read(self, iprot):
25125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25127 
      return
25128 
    iprot.readStructBegin()
25129 
    while True:
25130 
      (fname, ftype, fid) = iprot.readFieldBegin()
25131 
      if ftype == TType.STOP:
25132 
        break
25133 
      if fid == 1:
25134 
        if ftype == TType.STRING:
25135 
          self.agent = iprot.readString();
25136 
        else:
25137 
          iprot.skip(ftype)
25138 
      elif fid == 2:
25139 
        if ftype == TType.I64:
25140 
          self.orderId = iprot.readI64();
25141 
        else:
25142 
          iprot.skip(ftype)
25143 
      else:
25144 
        iprot.skip(ftype)
25145 
      iprot.readFieldEnd()
25146 
    iprot.readStructEnd()
25147 
 
25148 
  def write(self, oprot):
25149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25151 
      return
25152 
    oprot.writeStructBegin('updateCODAgent_args')
25153 
    if self.agent is not None:
25154 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25155 
      oprot.writeString(self.agent)
25156 
      oprot.writeFieldEnd()
25157 
    if self.orderId is not None:
25158 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25159 
      oprot.writeI64(self.orderId)
25160 
      oprot.writeFieldEnd()
25161 
    oprot.writeFieldStop()
25162 
    oprot.writeStructEnd()
25163 
 
25164 
  def validate(self):
25165 
    return
25166 
 
25167 
 
25168 
  def __repr__(self):
25169 
    L = ['%s=%r' % (key, value)
25170 
      for key, value in self.__dict__.iteritems()]
25171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25172 
 
25173 
  def __eq__(self, other):
25174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25175 
 
25176 
  def __ne__(self, other):
25177 
    return not (self == other)
25178 
 
25179 
class updateCODAgent_result:
25180 
  """
25181 
  Attributes:
25182 
   - ex
25183 
  """
25184 
 
25185 
  thrift_spec = (
25186 
    None, # 0
25187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25188 
  )
25189 
 
25190 
  def __init__(self, ex=None,):
25191 
    self.ex = ex
25192 
 
25193 
  def read(self, iprot):
25194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25196 
      return
25197 
    iprot.readStructBegin()
25198 
    while True:
25199 
      (fname, ftype, fid) = iprot.readFieldBegin()
25200 
      if ftype == TType.STOP:
25201 
        break
25202 
      if fid == 1:
25203 
        if ftype == TType.STRUCT:
25204 
          self.ex = TransactionServiceException()
25205 
          self.ex.read(iprot)
25206 
        else:
25207 
          iprot.skip(ftype)
25208 
      else:
25209 
        iprot.skip(ftype)
25210 
      iprot.readFieldEnd()
25211 
    iprot.readStructEnd()
25212 
 
25213 
  def write(self, oprot):
25214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25216 
      return
25217 
    oprot.writeStructBegin('updateCODAgent_result')
25218 
    if self.ex is not None:
25219 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25220 
      self.ex.write(oprot)
25221 
      oprot.writeFieldEnd()
25222 
    oprot.writeFieldStop()
25223 
    oprot.writeStructEnd()
25224 
 
25225 
  def validate(self):
25226 
    return
25227 
 
25228 
 
25229 
  def __repr__(self):
25230 
    L = ['%s=%r' % (key, value)
25231 
      for key, value in self.__dict__.iteritems()]
25232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25233 
 
25234 
  def __eq__(self, other):
25235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25236 
 
25237 
  def __ne__(self, other):
25238 
    return not (self == other)
25239 
 
5099 varun.gupt 25240 
class updateOrderAsPaidToVendor_args:
25241 
  """
25242 
  Attributes:
25243 
   - orderId
25244 
  """
25245 
 
25246 
  thrift_spec = (
25247 
    None, # 0
25248 
    (1, TType.I64, 'orderId', None, None, ), # 1
25249 
  )
25250 
 
25251 
  def __init__(self, orderId=None,):
25252 
    self.orderId = orderId
25253 
 
25254 
  def read(self, iprot):
25255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25257 
      return
25258 
    iprot.readStructBegin()
25259 
    while True:
25260 
      (fname, ftype, fid) = iprot.readFieldBegin()
25261 
      if ftype == TType.STOP:
25262 
        break
25263 
      if fid == 1:
25264 
        if ftype == TType.I64:
25265 
          self.orderId = iprot.readI64();
25266 
        else:
25267 
          iprot.skip(ftype)
25268 
      else:
25269 
        iprot.skip(ftype)
25270 
      iprot.readFieldEnd()
25271 
    iprot.readStructEnd()
25272 
 
25273 
  def write(self, oprot):
25274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25276 
      return
25277 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25278 
    if self.orderId is not None:
25279 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25280 
      oprot.writeI64(self.orderId)
25281 
      oprot.writeFieldEnd()
25282 
    oprot.writeFieldStop()
25283 
    oprot.writeStructEnd()
25284 
 
25285 
  def validate(self):
25286 
    return
25287 
 
25288 
 
25289 
  def __repr__(self):
25290 
    L = ['%s=%r' % (key, value)
25291 
      for key, value in self.__dict__.iteritems()]
25292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25293 
 
25294 
  def __eq__(self, other):
25295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25296 
 
25297 
  def __ne__(self, other):
25298 
    return not (self == other)
25299 
 
25300 
class updateOrderAsPaidToVendor_result:
25301 
  """
25302 
  Attributes:
25303 
   - ex
25304 
  """
25305 
 
25306 
  thrift_spec = (
25307 
    None, # 0
25308 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25309 
  )
25310 
 
25311 
  def __init__(self, ex=None,):
25312 
    self.ex = ex
25313 
 
25314 
  def read(self, iprot):
25315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25317 
      return
25318 
    iprot.readStructBegin()
25319 
    while True:
25320 
      (fname, ftype, fid) = iprot.readFieldBegin()
25321 
      if ftype == TType.STOP:
25322 
        break
25323 
      if fid == 1:
25324 
        if ftype == TType.STRUCT:
25325 
          self.ex = TransactionServiceException()
25326 
          self.ex.read(iprot)
25327 
        else:
25328 
          iprot.skip(ftype)
25329 
      else:
25330 
        iprot.skip(ftype)
25331 
      iprot.readFieldEnd()
25332 
    iprot.readStructEnd()
25333 
 
25334 
  def write(self, oprot):
25335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25337 
      return
25338 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25339 
    if self.ex is not None:
25340 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25341 
      self.ex.write(oprot)
25342 
      oprot.writeFieldEnd()
25343 
    oprot.writeFieldStop()
25344 
    oprot.writeStructEnd()
25345 
 
25346 
  def validate(self):
25347 
    return
25348 
 
25349 
 
25350 
  def __repr__(self):
25351 
    L = ['%s=%r' % (key, value)
25352 
      for key, value in self.__dict__.iteritems()]
25353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25354 
 
25355 
  def __eq__(self, other):
25356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25357 
 
25358 
  def __ne__(self, other):
25359 
    return not (self == other)
5208 varun.gupt 25360 
 
5386 phani.kuma 25361 
class updateOrderOnlyAsPaidToVendor_args:
25362 
  """
25363 
  Attributes:
25364 
   - orderId
25365 
  """
25366 
 
25367 
  thrift_spec = (
25368 
    None, # 0
25369 
    (1, TType.I64, 'orderId', None, None, ), # 1
25370 
  )
25371 
 
25372 
  def __init__(self, orderId=None,):
25373 
    self.orderId = orderId
25374 
 
25375 
  def read(self, iprot):
25376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25378 
      return
25379 
    iprot.readStructBegin()
25380 
    while True:
25381 
      (fname, ftype, fid) = iprot.readFieldBegin()
25382 
      if ftype == TType.STOP:
25383 
        break
25384 
      if fid == 1:
25385 
        if ftype == TType.I64:
25386 
          self.orderId = iprot.readI64();
25387 
        else:
25388 
          iprot.skip(ftype)
25389 
      else:
25390 
        iprot.skip(ftype)
25391 
      iprot.readFieldEnd()
25392 
    iprot.readStructEnd()
25393 
 
25394 
  def write(self, oprot):
25395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25397 
      return
25398 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25399 
    if self.orderId is not None:
25400 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25401 
      oprot.writeI64(self.orderId)
25402 
      oprot.writeFieldEnd()
25403 
    oprot.writeFieldStop()
25404 
    oprot.writeStructEnd()
25405 
 
25406 
  def validate(self):
25407 
    return
25408 
 
25409 
 
25410 
  def __repr__(self):
25411 
    L = ['%s=%r' % (key, value)
25412 
      for key, value in self.__dict__.iteritems()]
25413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25414 
 
25415 
  def __eq__(self, other):
25416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25417 
 
25418 
  def __ne__(self, other):
25419 
    return not (self == other)
25420 
 
25421 
class updateOrderOnlyAsPaidToVendor_result:
25422 
  """
25423 
  Attributes:
25424 
   - ex
25425 
  """
25426 
 
25427 
  thrift_spec = (
25428 
    None, # 0
25429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25430 
  )
25431 
 
25432 
  def __init__(self, ex=None,):
25433 
    self.ex = ex
25434 
 
25435 
  def read(self, iprot):
25436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25438 
      return
25439 
    iprot.readStructBegin()
25440 
    while True:
25441 
      (fname, ftype, fid) = iprot.readFieldBegin()
25442 
      if ftype == TType.STOP:
25443 
        break
25444 
      if fid == 1:
25445 
        if ftype == TType.STRUCT:
25446 
          self.ex = TransactionServiceException()
25447 
          self.ex.read(iprot)
25448 
        else:
25449 
          iprot.skip(ftype)
25450 
      else:
25451 
        iprot.skip(ftype)
25452 
      iprot.readFieldEnd()
25453 
    iprot.readStructEnd()
25454 
 
25455 
  def write(self, oprot):
25456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25458 
      return
25459 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25460 
    if self.ex is not None:
25461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25462 
      self.ex.write(oprot)
25463 
      oprot.writeFieldEnd()
25464 
    oprot.writeFieldStop()
25465 
    oprot.writeStructEnd()
25466 
 
25467 
  def validate(self):
25468 
    return
25469 
 
25470 
 
25471 
  def __repr__(self):
25472 
    L = ['%s=%r' % (key, value)
25473 
      for key, value in self.__dict__.iteritems()]
25474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25475 
 
25476 
  def __eq__(self, other):
25477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25478 
 
25479 
  def __ne__(self, other):
25480 
    return not (self == other)
25481 
 
5208 varun.gupt 25482 
class getRefundedOrdersMarkedPaid_args:
25483 
 
25484 
  thrift_spec = (
25485 
  )
25486 
 
25487 
  def read(self, iprot):
25488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25490 
      return
25491 
    iprot.readStructBegin()
25492 
    while True:
25493 
      (fname, ftype, fid) = iprot.readFieldBegin()
25494 
      if ftype == TType.STOP:
25495 
        break
25496 
      else:
25497 
        iprot.skip(ftype)
25498 
      iprot.readFieldEnd()
25499 
    iprot.readStructEnd()
25500 
 
25501 
  def write(self, oprot):
25502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25504 
      return
25505 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25506 
    oprot.writeFieldStop()
25507 
    oprot.writeStructEnd()
25508 
 
25509 
  def validate(self):
25510 
    return
25511 
 
25512 
 
25513 
  def __repr__(self):
25514 
    L = ['%s=%r' % (key, value)
25515 
      for key, value in self.__dict__.iteritems()]
25516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25517 
 
25518 
  def __eq__(self, other):
25519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25520 
 
25521 
  def __ne__(self, other):
25522 
    return not (self == other)
25523 
 
25524 
class getRefundedOrdersMarkedPaid_result:
25525 
  """
25526 
  Attributes:
25527 
   - success
25528 
   - ex
25529 
  """
25530 
 
25531 
  thrift_spec = (
25532 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25533 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25534 
  )
25535 
 
25536 
  def __init__(self, success=None, ex=None,):
25537 
    self.success = success
25538 
    self.ex = ex
25539 
 
25540 
  def read(self, iprot):
25541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25543 
      return
25544 
    iprot.readStructBegin()
25545 
    while True:
25546 
      (fname, ftype, fid) = iprot.readFieldBegin()
25547 
      if ftype == TType.STOP:
25548 
        break
25549 
      if fid == 0:
25550 
        if ftype == TType.LIST:
25551 
          self.success = []
6188 rajveer 25552 
          (_etype610, _size607) = iprot.readListBegin()
25553 
          for _i611 in xrange(_size607):
25554 
            _elem612 = Order()
25555 
            _elem612.read(iprot)
25556 
            self.success.append(_elem612)
5208 varun.gupt 25557 
          iprot.readListEnd()
25558 
        else:
25559 
          iprot.skip(ftype)
25560 
      elif fid == 1:
25561 
        if ftype == TType.STRUCT:
25562 
          self.ex = TransactionServiceException()
25563 
          self.ex.read(iprot)
25564 
        else:
25565 
          iprot.skip(ftype)
25566 
      else:
25567 
        iprot.skip(ftype)
25568 
      iprot.readFieldEnd()
25569 
    iprot.readStructEnd()
25570 
 
25571 
  def write(self, oprot):
25572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25574 
      return
25575 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25576 
    if self.success is not None:
25577 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25578 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25579 
      for iter613 in self.success:
25580 
        iter613.write(oprot)
5208 varun.gupt 25581 
      oprot.writeListEnd()
25582 
      oprot.writeFieldEnd()
25583 
    if self.ex is not None:
25584 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25585 
      self.ex.write(oprot)
25586 
      oprot.writeFieldEnd()
25587 
    oprot.writeFieldStop()
25588 
    oprot.writeStructEnd()
25589 
 
25590 
  def validate(self):
25591 
    return
25592 
 
25593 
 
25594 
  def __repr__(self):
25595 
    L = ['%s=%r' % (key, value)
25596 
      for key, value in self.__dict__.iteritems()]
25597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25598 
 
25599 
  def __eq__(self, other):
25600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25601 
 
25602 
  def __ne__(self, other):
25603 
    return not (self == other)
5447 anupam.sin 25604 
 
25605 
class getAllVerificationAgents_args:
25606 
  """
25607 
  Attributes:
25608 
   - minOrderId
25609 
   - maxOrderId
25610 
  """
25611 
 
25612 
  thrift_spec = (
25613 
    None, # 0
25614 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25615 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25616 
  )
25617 
 
25618 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25619 
    self.minOrderId = minOrderId
25620 
    self.maxOrderId = maxOrderId
25621 
 
25622 
  def read(self, iprot):
25623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25625 
      return
25626 
    iprot.readStructBegin()
25627 
    while True:
25628 
      (fname, ftype, fid) = iprot.readFieldBegin()
25629 
      if ftype == TType.STOP:
25630 
        break
25631 
      if fid == 1:
25632 
        if ftype == TType.I64:
25633 
          self.minOrderId = iprot.readI64();
25634 
        else:
25635 
          iprot.skip(ftype)
25636 
      elif fid == 2:
25637 
        if ftype == TType.I64:
25638 
          self.maxOrderId = iprot.readI64();
25639 
        else:
25640 
          iprot.skip(ftype)
25641 
      else:
25642 
        iprot.skip(ftype)
25643 
      iprot.readFieldEnd()
25644 
    iprot.readStructEnd()
25645 
 
25646 
  def write(self, oprot):
25647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25649 
      return
25650 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25651 
    if self.minOrderId is not None:
25652 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25653 
      oprot.writeI64(self.minOrderId)
25654 
      oprot.writeFieldEnd()
25655 
    if self.maxOrderId is not None:
25656 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25657 
      oprot.writeI64(self.maxOrderId)
25658 
      oprot.writeFieldEnd()
25659 
    oprot.writeFieldStop()
25660 
    oprot.writeStructEnd()
25661 
 
25662 
  def validate(self):
25663 
    return
25664 
 
25665 
 
25666 
  def __repr__(self):
25667 
    L = ['%s=%r' % (key, value)
25668 
      for key, value in self.__dict__.iteritems()]
25669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25670 
 
25671 
  def __eq__(self, other):
25672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25673 
 
25674 
  def __ne__(self, other):
25675 
    return not (self == other)
25676 
 
25677 
class getAllVerificationAgents_result:
25678 
  """
25679 
  Attributes:
25680 
   - success
25681 
  """
25682 
 
25683 
  thrift_spec = (
25684 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25685 
  )
25686 
 
25687 
  def __init__(self, success=None,):
25688 
    self.success = success
25689 
 
25690 
  def read(self, iprot):
25691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25693 
      return
25694 
    iprot.readStructBegin()
25695 
    while True:
25696 
      (fname, ftype, fid) = iprot.readFieldBegin()
25697 
      if ftype == TType.STOP:
25698 
        break
25699 
      if fid == 0:
25700 
        if ftype == TType.LIST:
25701 
          self.success = []
6188 rajveer 25702 
          (_etype617, _size614) = iprot.readListBegin()
25703 
          for _i618 in xrange(_size614):
25704 
            _elem619 = CODVerificationAgent()
25705 
            _elem619.read(iprot)
25706 
            self.success.append(_elem619)
5447 anupam.sin 25707 
          iprot.readListEnd()
25708 
        else:
25709 
          iprot.skip(ftype)
25710 
      else:
25711 
        iprot.skip(ftype)
25712 
      iprot.readFieldEnd()
25713 
    iprot.readStructEnd()
25714 
 
25715 
  def write(self, oprot):
25716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25718 
      return
25719 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25720 
    if self.success is not None:
25721 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25722 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25723 
      for iter620 in self.success:
25724 
        iter620.write(oprot)
5447 anupam.sin 25725 
      oprot.writeListEnd()
25726 
      oprot.writeFieldEnd()
25727 
    oprot.writeFieldStop()
25728 
    oprot.writeStructEnd()
25729 
 
25730 
  def validate(self):
25731 
    return
25732 
 
25733 
 
25734 
  def __repr__(self):
25735 
    L = ['%s=%r' % (key, value)
25736 
      for key, value in self.__dict__.iteritems()]
25737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25738 
 
25739 
  def __eq__(self, other):
25740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25741 
 
25742 
  def __ne__(self, other):
25743 
    return not (self == other)
5527 anupam.sin 25744 
 
25745 
class getAllAttributesForOrderId_args:
25746 
  """
25747 
  Attributes:
25748 
   - orderId
25749 
  """
25750 
 
25751 
  thrift_spec = (
25752 
    None, # 0
25753 
    (1, TType.I64, 'orderId', None, None, ), # 1
25754 
  )
25755 
 
25756 
  def __init__(self, orderId=None,):
25757 
    self.orderId = orderId
25758 
 
25759 
  def read(self, iprot):
25760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25762 
      return
25763 
    iprot.readStructBegin()
25764 
    while True:
25765 
      (fname, ftype, fid) = iprot.readFieldBegin()
25766 
      if ftype == TType.STOP:
25767 
        break
25768 
      if fid == 1:
25769 
        if ftype == TType.I64:
25770 
          self.orderId = iprot.readI64();
25771 
        else:
25772 
          iprot.skip(ftype)
25773 
      else:
25774 
        iprot.skip(ftype)
25775 
      iprot.readFieldEnd()
25776 
    iprot.readStructEnd()
25777 
 
25778 
  def write(self, oprot):
25779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25781 
      return
25782 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25783 
    if self.orderId is not None:
25784 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25785 
      oprot.writeI64(self.orderId)
25786 
      oprot.writeFieldEnd()
25787 
    oprot.writeFieldStop()
25788 
    oprot.writeStructEnd()
25789 
 
25790 
  def validate(self):
25791 
    return
25792 
 
25793 
 
25794 
  def __repr__(self):
25795 
    L = ['%s=%r' % (key, value)
25796 
      for key, value in self.__dict__.iteritems()]
25797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25798 
 
25799 
  def __eq__(self, other):
25800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25801 
 
25802 
  def __ne__(self, other):
25803 
    return not (self == other)
25804 
 
25805 
class getAllAttributesForOrderId_result:
25806 
  """
25807 
  Attributes:
25808 
   - success
25809 
  """
25810 
 
25811 
  thrift_spec = (
25812 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25813 
  )
25814 
 
25815 
  def __init__(self, success=None,):
25816 
    self.success = success
25817 
 
25818 
  def read(self, iprot):
25819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25821 
      return
25822 
    iprot.readStructBegin()
25823 
    while True:
25824 
      (fname, ftype, fid) = iprot.readFieldBegin()
25825 
      if ftype == TType.STOP:
25826 
        break
25827 
      if fid == 0:
25828 
        if ftype == TType.LIST:
25829 
          self.success = []
6188 rajveer 25830 
          (_etype624, _size621) = iprot.readListBegin()
25831 
          for _i625 in xrange(_size621):
25832 
            _elem626 = Attribute()
25833 
            _elem626.read(iprot)
25834 
            self.success.append(_elem626)
5527 anupam.sin 25835 
          iprot.readListEnd()
25836 
        else:
25837 
          iprot.skip(ftype)
25838 
      else:
25839 
        iprot.skip(ftype)
25840 
      iprot.readFieldEnd()
25841 
    iprot.readStructEnd()
25842 
 
25843 
  def write(self, oprot):
25844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25846 
      return
25847 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25848 
    if self.success is not None:
25849 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25850 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25851 
      for iter627 in self.success:
25852 
        iter627.write(oprot)
5527 anupam.sin 25853 
      oprot.writeListEnd()
25854 
      oprot.writeFieldEnd()
25855 
    oprot.writeFieldStop()
25856 
    oprot.writeStructEnd()
25857 
 
25858 
  def validate(self):
25859 
    return
25860 
 
25861 
 
25862 
  def __repr__(self):
25863 
    L = ['%s=%r' % (key, value)
25864 
      for key, value in self.__dict__.iteritems()]
25865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25866 
 
25867 
  def __eq__(self, other):
25868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25869 
 
25870 
  def __ne__(self, other):
25871 
    return not (self == other)
25872 
 
5676 rajveer 25873 
class setOrderAttributes_args:
25874 
  """
25875 
  Attributes:
25876 
   - orderId
25877 
   - attributes
25878 
  """
25879 
 
25880 
  thrift_spec = None
25881 
  def __init__(self, orderId=None, attributes=None,):
25882 
    self.orderId = orderId
25883 
    self.attributes = attributes
25884 
 
25885 
  def read(self, iprot):
25886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25888 
      return
25889 
    iprot.readStructBegin()
25890 
    while True:
25891 
      (fname, ftype, fid) = iprot.readFieldBegin()
25892 
      if ftype == TType.STOP:
25893 
        break
25894 
      if fid == 1:
25895 
        if ftype == TType.I64:
25896 
          self.orderId = iprot.readI64();
25897 
        else:
25898 
          iprot.skip(ftype)
25899 
      elif fid == -1:
25900 
        if ftype == TType.LIST:
25901 
          self.attributes = []
6188 rajveer 25902 
          (_etype631, _size628) = iprot.readListBegin()
25903 
          for _i632 in xrange(_size628):
25904 
            _elem633 = Attribute()
25905 
            _elem633.read(iprot)
25906 
            self.attributes.append(_elem633)
5676 rajveer 25907 
          iprot.readListEnd()
25908 
        else:
25909 
          iprot.skip(ftype)
25910 
      else:
25911 
        iprot.skip(ftype)
25912 
      iprot.readFieldEnd()
25913 
    iprot.readStructEnd()
25914 
 
25915 
  def write(self, oprot):
25916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25918 
      return
25919 
    oprot.writeStructBegin('setOrderAttributes_args')
25920 
    if self.attributes is not None:
25921 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25922 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25923 
      for iter634 in self.attributes:
25924 
        iter634.write(oprot)
5676 rajveer 25925 
      oprot.writeListEnd()
25926 
      oprot.writeFieldEnd()
25927 
    if self.orderId is not None:
25928 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25929 
      oprot.writeI64(self.orderId)
25930 
      oprot.writeFieldEnd()
25931 
    oprot.writeFieldStop()
25932 
    oprot.writeStructEnd()
25933 
 
25934 
  def validate(self):
25935 
    return
25936 
 
25937 
 
25938 
  def __repr__(self):
25939 
    L = ['%s=%r' % (key, value)
25940 
      for key, value in self.__dict__.iteritems()]
25941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25942 
 
25943 
  def __eq__(self, other):
25944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25945 
 
25946 
  def __ne__(self, other):
25947 
    return not (self == other)
25948 
 
25949 
class setOrderAttributes_result:
25950 
 
25951 
  thrift_spec = (
25952 
  )
25953 
 
25954 
  def read(self, iprot):
25955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25957 
      return
25958 
    iprot.readStructBegin()
25959 
    while True:
25960 
      (fname, ftype, fid) = iprot.readFieldBegin()
25961 
      if ftype == TType.STOP:
25962 
        break
25963 
      else:
25964 
        iprot.skip(ftype)
25965 
      iprot.readFieldEnd()
25966 
    iprot.readStructEnd()
25967 
 
25968 
  def write(self, oprot):
25969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25971 
      return
25972 
    oprot.writeStructBegin('setOrderAttributes_result')
25973 
    oprot.writeFieldStop()
25974 
    oprot.writeStructEnd()
25975 
 
25976 
  def validate(self):
25977 
    return
25978 
 
25979 
 
25980 
  def __repr__(self):
25981 
    L = ['%s=%r' % (key, value)
25982 
      for key, value in self.__dict__.iteritems()]
25983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25984 
 
25985 
  def __eq__(self, other):
25986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25987 
 
25988 
  def __ne__(self, other):
25989 
    return not (self == other)
25990 
 
5527 anupam.sin 25991 
class setOrderAttributeForTransaction_args:
25992 
  """
25993 
  Attributes:
25994 
   - transactionId
25995 
   - attribute
25996 
  """
25997 
 
25998 
  thrift_spec = None
25999 
  def __init__(self, transactionId=None, attribute=None,):
26000 
    self.transactionId = transactionId
26001 
    self.attribute = attribute
26002 
 
26003 
  def read(self, iprot):
26004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26006 
      return
26007 
    iprot.readStructBegin()
26008 
    while True:
26009 
      (fname, ftype, fid) = iprot.readFieldBegin()
26010 
      if ftype == TType.STOP:
26011 
        break
26012 
      if fid == 1:
26013 
        if ftype == TType.I64:
26014 
          self.transactionId = iprot.readI64();
26015 
        else:
26016 
          iprot.skip(ftype)
26017 
      elif fid == -1:
26018 
        if ftype == TType.STRUCT:
26019 
          self.attribute = Attribute()
26020 
          self.attribute.read(iprot)
26021 
        else:
26022 
          iprot.skip(ftype)
26023 
      else:
26024 
        iprot.skip(ftype)
26025 
      iprot.readFieldEnd()
26026 
    iprot.readStructEnd()
26027 
 
26028 
  def write(self, oprot):
26029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26031 
      return
26032 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26033 
    if self.attribute is not None:
26034 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26035 
      self.attribute.write(oprot)
26036 
      oprot.writeFieldEnd()
26037 
    if self.transactionId is not None:
26038 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26039 
      oprot.writeI64(self.transactionId)
26040 
      oprot.writeFieldEnd()
26041 
    oprot.writeFieldStop()
26042 
    oprot.writeStructEnd()
26043 
 
26044 
  def validate(self):
26045 
    return
26046 
 
26047 
 
26048 
  def __repr__(self):
26049 
    L = ['%s=%r' % (key, value)
26050 
      for key, value in self.__dict__.iteritems()]
26051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26052 
 
26053 
  def __eq__(self, other):
26054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26055 
 
26056 
  def __ne__(self, other):
26057 
    return not (self == other)
26058 
 
26059 
class setOrderAttributeForTransaction_result:
26060 
 
26061 
  thrift_spec = (
26062 
  )
26063 
 
26064 
  def read(self, iprot):
26065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26067 
      return
26068 
    iprot.readStructBegin()
26069 
    while True:
26070 
      (fname, ftype, fid) = iprot.readFieldBegin()
26071 
      if ftype == TType.STOP:
26072 
        break
26073 
      else:
26074 
        iprot.skip(ftype)
26075 
      iprot.readFieldEnd()
26076 
    iprot.readStructEnd()
26077 
 
26078 
  def write(self, oprot):
26079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26081 
      return
26082 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26083 
    oprot.writeFieldStop()
26084 
    oprot.writeStructEnd()
26085 
 
26086 
  def validate(self):
26087 
    return
26088 
 
26089 
 
26090 
  def __repr__(self):
26091 
    L = ['%s=%r' % (key, value)
26092 
      for key, value in self.__dict__.iteritems()]
26093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26094 
 
26095 
  def __eq__(self, other):
26096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26097 
 
26098 
  def __ne__(self, other):
26099 
    return not (self == other)
5553 rajveer 26100 
 
26101 
class getReceivePendingOrders_args:
26102 
  """
26103 
  Attributes:
26104 
   - storeId
26105 
  """
26106 
 
26107 
  thrift_spec = (
26108 
    None, # 0
26109 
    (1, TType.I64, 'storeId', None, None, ), # 1
26110 
  )
26111 
 
26112 
  def __init__(self, storeId=None,):
26113 
    self.storeId = storeId
26114 
 
26115 
  def read(self, iprot):
26116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26118 
      return
26119 
    iprot.readStructBegin()
26120 
    while True:
26121 
      (fname, ftype, fid) = iprot.readFieldBegin()
26122 
      if ftype == TType.STOP:
26123 
        break
26124 
      if fid == 1:
26125 
        if ftype == TType.I64:
26126 
          self.storeId = iprot.readI64();
26127 
        else:
26128 
          iprot.skip(ftype)
26129 
      else:
26130 
        iprot.skip(ftype)
26131 
      iprot.readFieldEnd()
26132 
    iprot.readStructEnd()
26133 
 
26134 
  def write(self, oprot):
26135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26137 
      return
26138 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26139 
    if self.storeId is not None:
26140 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26141 
      oprot.writeI64(self.storeId)
26142 
      oprot.writeFieldEnd()
26143 
    oprot.writeFieldStop()
26144 
    oprot.writeStructEnd()
26145 
 
26146 
  def validate(self):
26147 
    return
26148 
 
26149 
 
26150 
  def __repr__(self):
26151 
    L = ['%s=%r' % (key, value)
26152 
      for key, value in self.__dict__.iteritems()]
26153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26154 
 
26155 
  def __eq__(self, other):
26156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26157 
 
26158 
  def __ne__(self, other):
26159 
    return not (self == other)
26160 
 
26161 
class getReceivePendingOrders_result:
26162 
  """
26163 
  Attributes:
26164 
   - success
26165 
  """
26166 
 
26167 
  thrift_spec = (
26168 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26169 
  )
26170 
 
26171 
  def __init__(self, success=None,):
26172 
    self.success = success
26173 
 
26174 
  def read(self, iprot):
26175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26177 
      return
26178 
    iprot.readStructBegin()
26179 
    while True:
26180 
      (fname, ftype, fid) = iprot.readFieldBegin()
26181 
      if ftype == TType.STOP:
26182 
        break
26183 
      if fid == 0:
26184 
        if ftype == TType.LIST:
26185 
          self.success = []
6188 rajveer 26186 
          (_etype638, _size635) = iprot.readListBegin()
26187 
          for _i639 in xrange(_size635):
26188 
            _elem640 = Order()
26189 
            _elem640.read(iprot)
26190 
            self.success.append(_elem640)
5553 rajveer 26191 
          iprot.readListEnd()
26192 
        else:
26193 
          iprot.skip(ftype)
26194 
      else:
26195 
        iprot.skip(ftype)
26196 
      iprot.readFieldEnd()
26197 
    iprot.readStructEnd()
26198 
 
26199 
  def write(self, oprot):
26200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26202 
      return
26203 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26204 
    if self.success is not None:
26205 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26206 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26207 
      for iter641 in self.success:
26208 
        iter641.write(oprot)
5553 rajveer 26209 
      oprot.writeListEnd()
26210 
      oprot.writeFieldEnd()
26211 
    oprot.writeFieldStop()
26212 
    oprot.writeStructEnd()
26213 
 
26214 
  def validate(self):
26215 
    return
26216 
 
26217 
 
26218 
  def __repr__(self):
26219 
    L = ['%s=%r' % (key, value)
26220 
      for key, value in self.__dict__.iteritems()]
26221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26222 
 
26223 
  def __eq__(self, other):
26224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26225 
 
26226 
  def __ne__(self, other):
26227 
    return not (self == other)
26228 
 
26229 
class getReceivedAtStoreOrders_args:
26230 
  """
26231 
  Attributes:
26232 
   - storeId
26233 
  """
26234 
 
26235 
  thrift_spec = (
26236 
    None, # 0
26237 
    (1, TType.I64, 'storeId', None, None, ), # 1
26238 
  )
26239 
 
26240 
  def __init__(self, storeId=None,):
26241 
    self.storeId = storeId
26242 
 
26243 
  def read(self, iprot):
26244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26246 
      return
26247 
    iprot.readStructBegin()
26248 
    while True:
26249 
      (fname, ftype, fid) = iprot.readFieldBegin()
26250 
      if ftype == TType.STOP:
26251 
        break
26252 
      if fid == 1:
26253 
        if ftype == TType.I64:
26254 
          self.storeId = iprot.readI64();
26255 
        else:
26256 
          iprot.skip(ftype)
26257 
      else:
26258 
        iprot.skip(ftype)
26259 
      iprot.readFieldEnd()
26260 
    iprot.readStructEnd()
26261 
 
26262 
  def write(self, oprot):
26263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26265 
      return
26266 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26267 
    if self.storeId is not None:
26268 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26269 
      oprot.writeI64(self.storeId)
26270 
      oprot.writeFieldEnd()
26271 
    oprot.writeFieldStop()
26272 
    oprot.writeStructEnd()
26273 
 
26274 
  def validate(self):
26275 
    return
26276 
 
26277 
 
26278 
  def __repr__(self):
26279 
    L = ['%s=%r' % (key, value)
26280 
      for key, value in self.__dict__.iteritems()]
26281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26282 
 
26283 
  def __eq__(self, other):
26284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26285 
 
26286 
  def __ne__(self, other):
26287 
    return not (self == other)
26288 
 
26289 
class getReceivedAtStoreOrders_result:
26290 
  """
26291 
  Attributes:
26292 
   - success
26293 
  """
26294 
 
26295 
  thrift_spec = (
26296 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26297 
  )
26298 
 
26299 
  def __init__(self, success=None,):
26300 
    self.success = success
26301 
 
26302 
  def read(self, iprot):
26303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26305 
      return
26306 
    iprot.readStructBegin()
26307 
    while True:
26308 
      (fname, ftype, fid) = iprot.readFieldBegin()
26309 
      if ftype == TType.STOP:
26310 
        break
26311 
      if fid == 0:
26312 
        if ftype == TType.LIST:
26313 
          self.success = []
6188 rajveer 26314 
          (_etype645, _size642) = iprot.readListBegin()
26315 
          for _i646 in xrange(_size642):
26316 
            _elem647 = Order()
26317 
            _elem647.read(iprot)
26318 
            self.success.append(_elem647)
5553 rajveer 26319 
          iprot.readListEnd()
26320 
        else:
26321 
          iprot.skip(ftype)
26322 
      else:
26323 
        iprot.skip(ftype)
26324 
      iprot.readFieldEnd()
26325 
    iprot.readStructEnd()
26326 
 
26327 
  def write(self, oprot):
26328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26330 
      return
26331 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26332 
    if self.success is not None:
26333 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26334 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26335 
      for iter648 in self.success:
26336 
        iter648.write(oprot)
5553 rajveer 26337 
      oprot.writeListEnd()
26338 
      oprot.writeFieldEnd()
26339 
    oprot.writeFieldStop()
26340 
    oprot.writeStructEnd()
26341 
 
26342 
  def validate(self):
26343 
    return
26344 
 
26345 
 
26346 
  def __repr__(self):
26347 
    L = ['%s=%r' % (key, value)
26348 
      for key, value in self.__dict__.iteritems()]
26349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26350 
 
26351 
  def __eq__(self, other):
26352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26353 
 
26354 
  def __ne__(self, other):
26355 
    return not (self == other)
5593 mandeep.dh 26356 
 
5713 rajveer 26357 
class getOrdersCollectionAtStore_args:
26358 
  """
26359 
  Attributes:
26360 
   - storeId
26361 
   - fromDate
26362 
   - toDate
26363 
   - onlyCod
26364 
  """
26365 
 
26366 
  thrift_spec = (
26367 
    None, # 0
26368 
    (1, TType.I64, 'storeId', None, None, ), # 1
26369 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26370 
    (3, TType.I64, 'toDate', None, None, ), # 3
26371 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26372 
  )
26373 
 
26374 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26375 
    self.storeId = storeId
26376 
    self.fromDate = fromDate
26377 
    self.toDate = toDate
26378 
    self.onlyCod = onlyCod
26379 
 
26380 
  def read(self, iprot):
26381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26383 
      return
26384 
    iprot.readStructBegin()
26385 
    while True:
26386 
      (fname, ftype, fid) = iprot.readFieldBegin()
26387 
      if ftype == TType.STOP:
26388 
        break
26389 
      if fid == 1:
26390 
        if ftype == TType.I64:
26391 
          self.storeId = iprot.readI64();
26392 
        else:
26393 
          iprot.skip(ftype)
26394 
      elif fid == 2:
26395 
        if ftype == TType.I64:
26396 
          self.fromDate = iprot.readI64();
26397 
        else:
26398 
          iprot.skip(ftype)
26399 
      elif fid == 3:
26400 
        if ftype == TType.I64:
26401 
          self.toDate = iprot.readI64();
26402 
        else:
26403 
          iprot.skip(ftype)
26404 
      elif fid == 4:
26405 
        if ftype == TType.BOOL:
26406 
          self.onlyCod = iprot.readBool();
26407 
        else:
26408 
          iprot.skip(ftype)
26409 
      else:
26410 
        iprot.skip(ftype)
26411 
      iprot.readFieldEnd()
26412 
    iprot.readStructEnd()
26413 
 
26414 
  def write(self, oprot):
26415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26417 
      return
26418 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26419 
    if self.storeId is not None:
26420 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26421 
      oprot.writeI64(self.storeId)
26422 
      oprot.writeFieldEnd()
26423 
    if self.fromDate is not None:
26424 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26425 
      oprot.writeI64(self.fromDate)
26426 
      oprot.writeFieldEnd()
26427 
    if self.toDate is not None:
26428 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26429 
      oprot.writeI64(self.toDate)
26430 
      oprot.writeFieldEnd()
26431 
    if self.onlyCod is not None:
26432 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26433 
      oprot.writeBool(self.onlyCod)
26434 
      oprot.writeFieldEnd()
26435 
    oprot.writeFieldStop()
26436 
    oprot.writeStructEnd()
26437 
 
26438 
  def validate(self):
26439 
    return
26440 
 
26441 
 
26442 
  def __repr__(self):
26443 
    L = ['%s=%r' % (key, value)
26444 
      for key, value in self.__dict__.iteritems()]
26445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26446 
 
26447 
  def __eq__(self, other):
26448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26449 
 
26450 
  def __ne__(self, other):
26451 
    return not (self == other)
26452 
 
26453 
class getOrdersCollectionAtStore_result:
26454 
  """
26455 
  Attributes:
26456 
   - success
26457 
  """
26458 
 
26459 
  thrift_spec = (
26460 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26461 
  )
26462 
 
26463 
  def __init__(self, success=None,):
26464 
    self.success = success
26465 
 
26466 
  def read(self, iprot):
26467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26469 
      return
26470 
    iprot.readStructBegin()
26471 
    while True:
26472 
      (fname, ftype, fid) = iprot.readFieldBegin()
26473 
      if ftype == TType.STOP:
26474 
        break
26475 
      if fid == 0:
26476 
        if ftype == TType.LIST:
26477 
          self.success = []
6188 rajveer 26478 
          (_etype652, _size649) = iprot.readListBegin()
26479 
          for _i653 in xrange(_size649):
26480 
            _elem654 = Order()
26481 
            _elem654.read(iprot)
26482 
            self.success.append(_elem654)
5713 rajveer 26483 
          iprot.readListEnd()
26484 
        else:
26485 
          iprot.skip(ftype)
26486 
      else:
26487 
        iprot.skip(ftype)
26488 
      iprot.readFieldEnd()
26489 
    iprot.readStructEnd()
26490 
 
26491 
  def write(self, oprot):
26492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26494 
      return
26495 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26496 
    if self.success is not None:
26497 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26498 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26499 
      for iter655 in self.success:
26500 
        iter655.write(oprot)
5713 rajveer 26501 
      oprot.writeListEnd()
26502 
      oprot.writeFieldEnd()
26503 
    oprot.writeFieldStop()
26504 
    oprot.writeStructEnd()
26505 
 
26506 
  def validate(self):
26507 
    return
26508 
 
26509 
 
26510 
  def __repr__(self):
26511 
    L = ['%s=%r' % (key, value)
26512 
      for key, value in self.__dict__.iteritems()]
26513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26514 
 
26515 
  def __eq__(self, other):
26516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26517 
 
26518 
  def __ne__(self, other):
26519 
    return not (self == other)
26520 
 
5833 rajveer 26521 
class getOrderAttributeValue_args:
26522 
  """
26523 
  Attributes:
26524 
   - orderId
26525 
   - attributeName
26526 
  """
26527 
 
26528 
  thrift_spec = None
26529 
  def __init__(self, orderId=None, attributeName=None,):
26530 
    self.orderId = orderId
26531 
    self.attributeName = attributeName
26532 
 
26533 
  def read(self, iprot):
26534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26536 
      return
26537 
    iprot.readStructBegin()
26538 
    while True:
26539 
      (fname, ftype, fid) = iprot.readFieldBegin()
26540 
      if ftype == TType.STOP:
26541 
        break
26542 
      if fid == 1:
26543 
        if ftype == TType.I64:
26544 
          self.orderId = iprot.readI64();
26545 
        else:
26546 
          iprot.skip(ftype)
26547 
      elif fid == -1:
26548 
        if ftype == TType.STRING:
26549 
          self.attributeName = iprot.readString();
26550 
        else:
26551 
          iprot.skip(ftype)
26552 
      else:
26553 
        iprot.skip(ftype)
26554 
      iprot.readFieldEnd()
26555 
    iprot.readStructEnd()
26556 
 
26557 
  def write(self, oprot):
26558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26560 
      return
26561 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26562 
    if self.attributeName is not None:
26563 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26564 
      oprot.writeString(self.attributeName)
26565 
      oprot.writeFieldEnd()
26566 
    if self.orderId is not None:
26567 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26568 
      oprot.writeI64(self.orderId)
26569 
      oprot.writeFieldEnd()
26570 
    oprot.writeFieldStop()
26571 
    oprot.writeStructEnd()
26572 
 
26573 
  def validate(self):
26574 
    return
26575 
 
26576 
 
26577 
  def __repr__(self):
26578 
    L = ['%s=%r' % (key, value)
26579 
      for key, value in self.__dict__.iteritems()]
26580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26581 
 
26582 
  def __eq__(self, other):
26583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26584 
 
26585 
  def __ne__(self, other):
26586 
    return not (self == other)
26587 
 
26588 
class getOrderAttributeValue_result:
26589 
  """
26590 
  Attributes:
26591 
   - success
26592 
  """
26593 
 
26594 
  thrift_spec = (
26595 
    (0, TType.STRING, 'success', None, None, ), # 0
26596 
  )
26597 
 
26598 
  def __init__(self, success=None,):
26599 
    self.success = success
26600 
 
26601 
  def read(self, iprot):
26602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26604 
      return
26605 
    iprot.readStructBegin()
26606 
    while True:
26607 
      (fname, ftype, fid) = iprot.readFieldBegin()
26608 
      if ftype == TType.STOP:
26609 
        break
26610 
      if fid == 0:
26611 
        if ftype == TType.STRING:
26612 
          self.success = iprot.readString();
26613 
        else:
26614 
          iprot.skip(ftype)
26615 
      else:
26616 
        iprot.skip(ftype)
26617 
      iprot.readFieldEnd()
26618 
    iprot.readStructEnd()
26619 
 
26620 
  def write(self, oprot):
26621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26623 
      return
26624 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26625 
    if self.success is not None:
26626 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26627 
      oprot.writeString(self.success)
26628 
      oprot.writeFieldEnd()
26629 
    oprot.writeFieldStop()
26630 
    oprot.writeStructEnd()
26631 
 
26632 
  def validate(self):
26633 
    return
26634 
 
26635 
 
26636 
  def __repr__(self):
26637 
    L = ['%s=%r' % (key, value)
26638 
      for key, value in self.__dict__.iteritems()]
26639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26640 
 
26641 
  def __eq__(self, other):
26642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26643 
 
26644 
  def __ne__(self, other):
26645 
    return not (self == other)
26646 
 
6019 rajveer 26647 
class changeJacketNumber_args:
26648 
  """
26649 
  Attributes:
26650 
   - orderId
26651 
   - jacketNumber
26652 
  """
26653 
 
26654 
  thrift_spec = (
26655 
    None, # 0
26656 
    (1, TType.I64, 'orderId', None, None, ), # 1
26657 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26658 
  )
26659 
 
26660 
  def __init__(self, orderId=None, jacketNumber=None,):
26661 
    self.orderId = orderId
26662 
    self.jacketNumber = jacketNumber
26663 
 
26664 
  def read(self, iprot):
26665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26667 
      return
26668 
    iprot.readStructBegin()
26669 
    while True:
26670 
      (fname, ftype, fid) = iprot.readFieldBegin()
26671 
      if ftype == TType.STOP:
26672 
        break
26673 
      if fid == 1:
26674 
        if ftype == TType.I64:
26675 
          self.orderId = iprot.readI64();
26676 
        else:
26677 
          iprot.skip(ftype)
26678 
      elif fid == 2:
26679 
        if ftype == TType.I64:
26680 
          self.jacketNumber = iprot.readI64();
26681 
        else:
26682 
          iprot.skip(ftype)
26683 
      else:
26684 
        iprot.skip(ftype)
26685 
      iprot.readFieldEnd()
26686 
    iprot.readStructEnd()
26687 
 
26688 
  def write(self, oprot):
26689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26691 
      return
26692 
    oprot.writeStructBegin('changeJacketNumber_args')
26693 
    if self.orderId is not None:
26694 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26695 
      oprot.writeI64(self.orderId)
26696 
      oprot.writeFieldEnd()
26697 
    if self.jacketNumber is not None:
26698 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26699 
      oprot.writeI64(self.jacketNumber)
26700 
      oprot.writeFieldEnd()
26701 
    oprot.writeFieldStop()
26702 
    oprot.writeStructEnd()
26703 
 
26704 
  def validate(self):
26705 
    return
26706 
 
26707 
 
26708 
  def __repr__(self):
26709 
    L = ['%s=%r' % (key, value)
26710 
      for key, value in self.__dict__.iteritems()]
26711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26712 
 
26713 
  def __eq__(self, other):
26714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26715 
 
26716 
  def __ne__(self, other):
26717 
    return not (self == other)
26718 
 
26719 
class changeJacketNumber_result:
26720 
  """
26721 
  Attributes:
26722 
   - success
26723 
  """
26724 
 
26725 
  thrift_spec = (
26726 
    (0, TType.BOOL, 'success', None, None, ), # 0
26727 
  )
26728 
 
26729 
  def __init__(self, success=None,):
26730 
    self.success = success
26731 
 
26732 
  def read(self, iprot):
26733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26735 
      return
26736 
    iprot.readStructBegin()
26737 
    while True:
26738 
      (fname, ftype, fid) = iprot.readFieldBegin()
26739 
      if ftype == TType.STOP:
26740 
        break
26741 
      if fid == 0:
26742 
        if ftype == TType.BOOL:
26743 
          self.success = iprot.readBool();
26744 
        else:
26745 
          iprot.skip(ftype)
26746 
      else:
26747 
        iprot.skip(ftype)
26748 
      iprot.readFieldEnd()
26749 
    iprot.readStructEnd()
26750 
 
26751 
  def write(self, oprot):
26752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26754 
      return
26755 
    oprot.writeStructBegin('changeJacketNumber_result')
26756 
    if self.success is not None:
26757 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26758 
      oprot.writeBool(self.success)
26759 
      oprot.writeFieldEnd()
26760 
    oprot.writeFieldStop()
26761 
    oprot.writeStructEnd()
26762 
 
26763 
  def validate(self):
26764 
    return
26765 
 
26766 
 
26767 
  def __repr__(self):
26768 
    L = ['%s=%r' % (key, value)
26769 
      for key, value in self.__dict__.iteritems()]
26770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26771 
 
26772 
  def __eq__(self, other):
26773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26774 
 
26775 
  def __ne__(self, other):
26776 
    return not (self == other)
26777 
 
26778 
class markOrderAsRtoInTransit_args:
26779 
  """
26780 
  Attributes:
26781 
   - orderId
26782 
  """
26783 
 
26784 
  thrift_spec = (
26785 
    None, # 0
26786 
    (1, TType.I64, 'orderId', None, None, ), # 1
26787 
  )
26788 
 
26789 
  def __init__(self, orderId=None,):
26790 
    self.orderId = orderId
26791 
 
26792 
  def read(self, iprot):
26793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26795 
      return
26796 
    iprot.readStructBegin()
26797 
    while True:
26798 
      (fname, ftype, fid) = iprot.readFieldBegin()
26799 
      if ftype == TType.STOP:
26800 
        break
26801 
      if fid == 1:
26802 
        if ftype == TType.I64:
26803 
          self.orderId = iprot.readI64();
26804 
        else:
26805 
          iprot.skip(ftype)
26806 
      else:
26807 
        iprot.skip(ftype)
26808 
      iprot.readFieldEnd()
26809 
    iprot.readStructEnd()
26810 
 
26811 
  def write(self, oprot):
26812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26814 
      return
26815 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26816 
    if self.orderId is not None:
26817 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26818 
      oprot.writeI64(self.orderId)
26819 
      oprot.writeFieldEnd()
26820 
    oprot.writeFieldStop()
26821 
    oprot.writeStructEnd()
26822 
 
26823 
  def validate(self):
26824 
    return
26825 
 
26826 
 
26827 
  def __repr__(self):
26828 
    L = ['%s=%r' % (key, value)
26829 
      for key, value in self.__dict__.iteritems()]
26830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26831 
 
26832 
  def __eq__(self, other):
26833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26834 
 
26835 
  def __ne__(self, other):
26836 
    return not (self == other)
26837 
 
26838 
class markOrderAsRtoInTransit_result:
26839 
  """
26840 
  Attributes:
26841 
   - success
26842 
  """
26843 
 
26844 
  thrift_spec = (
26845 
    (0, TType.BOOL, 'success', None, None, ), # 0
26846 
  )
26847 
 
26848 
  def __init__(self, success=None,):
26849 
    self.success = success
26850 
 
26851 
  def read(self, iprot):
26852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26854 
      return
26855 
    iprot.readStructBegin()
26856 
    while True:
26857 
      (fname, ftype, fid) = iprot.readFieldBegin()
26858 
      if ftype == TType.STOP:
26859 
        break
26860 
      if fid == 0:
26861 
        if ftype == TType.BOOL:
26862 
          self.success = iprot.readBool();
26863 
        else:
26864 
          iprot.skip(ftype)
26865 
      else:
26866 
        iprot.skip(ftype)
26867 
      iprot.readFieldEnd()
26868 
    iprot.readStructEnd()
26869 
 
26870 
  def write(self, oprot):
26871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26873 
      return
26874 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26875 
    if self.success is not None:
26876 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26877 
      oprot.writeBool(self.success)
26878 
      oprot.writeFieldEnd()
26879 
    oprot.writeFieldStop()
26880 
    oprot.writeStructEnd()
26881 
 
26882 
  def validate(self):
26883 
    return
26884 
 
26885 
 
26886 
  def __repr__(self):
26887 
    L = ['%s=%r' % (key, value)
26888 
      for key, value in self.__dict__.iteritems()]
26889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26890 
 
26891 
  def __eq__(self, other):
26892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26893 
 
26894 
  def __ne__(self, other):
26895 
    return not (self == other)
26896 
 
5593 mandeep.dh 26897 
class acceptOrderForItem_args:
26898 
  """
26899 
  Attributes:
26900 
   - itemId
26901 
   - quantity
26902 
   - fulfilmentWarehouseId
26903 
   - billingWarehouseId
26904 
  """
26905 
 
26906 
  thrift_spec = (
26907 
    None, # 0
26908 
    (1, TType.I64, 'itemId', None, None, ), # 1
26909 
    (2, TType.I64, 'quantity', None, None, ), # 2
26910 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26911 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26912 
  )
26913 
 
26914 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26915 
    self.itemId = itemId
26916 
    self.quantity = quantity
26917 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26918 
    self.billingWarehouseId = billingWarehouseId
26919 
 
26920 
  def read(self, iprot):
26921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26923 
      return
26924 
    iprot.readStructBegin()
26925 
    while True:
26926 
      (fname, ftype, fid) = iprot.readFieldBegin()
26927 
      if ftype == TType.STOP:
26928 
        break
26929 
      if fid == 1:
26930 
        if ftype == TType.I64:
26931 
          self.itemId = iprot.readI64();
26932 
        else:
26933 
          iprot.skip(ftype)
26934 
      elif fid == 2:
26935 
        if ftype == TType.I64:
26936 
          self.quantity = iprot.readI64();
26937 
        else:
26938 
          iprot.skip(ftype)
26939 
      elif fid == 3:
26940 
        if ftype == TType.I64:
26941 
          self.fulfilmentWarehouseId = iprot.readI64();
26942 
        else:
26943 
          iprot.skip(ftype)
26944 
      elif fid == 4:
26945 
        if ftype == TType.I64:
26946 
          self.billingWarehouseId = iprot.readI64();
26947 
        else:
26948 
          iprot.skip(ftype)
26949 
      else:
26950 
        iprot.skip(ftype)
26951 
      iprot.readFieldEnd()
26952 
    iprot.readStructEnd()
26953 
 
26954 
  def write(self, oprot):
26955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26957 
      return
26958 
    oprot.writeStructBegin('acceptOrderForItem_args')
26959 
    if self.itemId is not None:
26960 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26961 
      oprot.writeI64(self.itemId)
26962 
      oprot.writeFieldEnd()
26963 
    if self.quantity is not None:
26964 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26965 
      oprot.writeI64(self.quantity)
26966 
      oprot.writeFieldEnd()
26967 
    if self.fulfilmentWarehouseId is not None:
26968 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26969 
      oprot.writeI64(self.fulfilmentWarehouseId)
26970 
      oprot.writeFieldEnd()
26971 
    if self.billingWarehouseId is not None:
26972 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26973 
      oprot.writeI64(self.billingWarehouseId)
26974 
      oprot.writeFieldEnd()
26975 
    oprot.writeFieldStop()
26976 
    oprot.writeStructEnd()
26977 
 
26978 
  def validate(self):
26979 
    return
26980 
 
26981 
 
26982 
  def __repr__(self):
26983 
    L = ['%s=%r' % (key, value)
26984 
      for key, value in self.__dict__.iteritems()]
26985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26986 
 
26987 
  def __eq__(self, other):
26988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26989 
 
26990 
  def __ne__(self, other):
26991 
    return not (self == other)
26992 
 
26993 
class acceptOrderForItem_result:
26994 
 
26995 
  thrift_spec = (
26996 
  )
26997 
 
26998 
  def read(self, iprot):
26999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27001 
      return
27002 
    iprot.readStructBegin()
27003 
    while True:
27004 
      (fname, ftype, fid) = iprot.readFieldBegin()
27005 
      if ftype == TType.STOP:
27006 
        break
27007 
      else:
27008 
        iprot.skip(ftype)
27009 
      iprot.readFieldEnd()
27010 
    iprot.readStructEnd()
27011 
 
27012 
  def write(self, oprot):
27013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27015 
      return
27016 
    oprot.writeStructBegin('acceptOrderForItem_result')
27017 
    oprot.writeFieldStop()
27018 
    oprot.writeStructEnd()
27019 
 
27020 
  def validate(self):
27021 
    return
27022 
 
27023 
 
27024 
  def __repr__(self):
27025 
    L = ['%s=%r' % (key, value)
27026 
      for key, value in self.__dict__.iteritems()]
27027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27028 
 
27029 
  def __eq__(self, other):
27030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27031 
 
27032 
  def __ne__(self, other):
27033 
    return not (self == other)
6000 mandeep.dh 27034 
 
27035 
class createRechargeOrder_args:
27036 
  """
27037 
  Attributes:
27038 
   - rechargeOrder
27039 
  """
27040 
 
27041 
  thrift_spec = (
27042 
    None, # 0
27043 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27044 
  )
27045 
 
27046 
  def __init__(self, rechargeOrder=None,):
27047 
    self.rechargeOrder = rechargeOrder
27048 
 
27049 
  def read(self, iprot):
27050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27052 
      return
27053 
    iprot.readStructBegin()
27054 
    while True:
27055 
      (fname, ftype, fid) = iprot.readFieldBegin()
27056 
      if ftype == TType.STOP:
27057 
        break
27058 
      if fid == 1:
27059 
        if ftype == TType.STRUCT:
27060 
          self.rechargeOrder = RechargeOrder()
27061 
          self.rechargeOrder.read(iprot)
27062 
        else:
27063 
          iprot.skip(ftype)
27064 
      else:
27065 
        iprot.skip(ftype)
27066 
      iprot.readFieldEnd()
27067 
    iprot.readStructEnd()
27068 
 
27069 
  def write(self, oprot):
27070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27072 
      return
27073 
    oprot.writeStructBegin('createRechargeOrder_args')
27074 
    if self.rechargeOrder is not None:
27075 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27076 
      self.rechargeOrder.write(oprot)
27077 
      oprot.writeFieldEnd()
27078 
    oprot.writeFieldStop()
27079 
    oprot.writeStructEnd()
27080 
 
27081 
  def validate(self):
27082 
    return
27083 
 
27084 
 
27085 
  def __repr__(self):
27086 
    L = ['%s=%r' % (key, value)
27087 
      for key, value in self.__dict__.iteritems()]
27088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27089 
 
27090 
  def __eq__(self, other):
27091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27092 
 
27093 
  def __ne__(self, other):
27094 
    return not (self == other)
27095 
 
27096 
class createRechargeOrder_result:
27097 
  """
27098 
  Attributes:
27099 
   - success
27100 
   - ex
27101 
  """
27102 
 
27103 
  thrift_spec = (
27104 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27106 
  )
27107 
 
27108 
  def __init__(self, success=None, ex=None,):
27109 
    self.success = success
27110 
    self.ex = ex
27111 
 
27112 
  def read(self, iprot):
27113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27115 
      return
27116 
    iprot.readStructBegin()
27117 
    while True:
27118 
      (fname, ftype, fid) = iprot.readFieldBegin()
27119 
      if ftype == TType.STOP:
27120 
        break
27121 
      if fid == 0:
27122 
        if ftype == TType.STRUCT:
27123 
          self.success = RechargeOrder()
27124 
          self.success.read(iprot)
27125 
        else:
27126 
          iprot.skip(ftype)
27127 
      elif fid == 1:
27128 
        if ftype == TType.STRUCT:
27129 
          self.ex = TransactionServiceException()
27130 
          self.ex.read(iprot)
27131 
        else:
27132 
          iprot.skip(ftype)
27133 
      else:
27134 
        iprot.skip(ftype)
27135 
      iprot.readFieldEnd()
27136 
    iprot.readStructEnd()
27137 
 
27138 
  def write(self, oprot):
27139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27141 
      return
27142 
    oprot.writeStructBegin('createRechargeOrder_result')
27143 
    if self.success is not None:
27144 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27145 
      self.success.write(oprot)
27146 
      oprot.writeFieldEnd()
27147 
    if self.ex is not None:
27148 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27149 
      self.ex.write(oprot)
27150 
      oprot.writeFieldEnd()
27151 
    oprot.writeFieldStop()
27152 
    oprot.writeStructEnd()
27153 
 
27154 
  def validate(self):
27155 
    return
27156 
 
27157 
 
27158 
  def __repr__(self):
27159 
    L = ['%s=%r' % (key, value)
27160 
      for key, value in self.__dict__.iteritems()]
27161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27162 
 
27163 
  def __eq__(self, other):
27164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27165 
 
27166 
  def __ne__(self, other):
27167 
    return not (self == other)
27168 
 
6031 rajveer 27169 
class getRechargeOrder_args:
27170 
  """
27171 
  Attributes:
27172 
   - rechargeRrderId
27173 
  """
27174 
 
27175 
  thrift_spec = (
27176 
    None, # 0
27177 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27178 
  )
27179 
 
27180 
  def __init__(self, rechargeRrderId=None,):
27181 
    self.rechargeRrderId = rechargeRrderId
27182 
 
27183 
  def read(self, iprot):
27184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27186 
      return
27187 
    iprot.readStructBegin()
27188 
    while True:
27189 
      (fname, ftype, fid) = iprot.readFieldBegin()
27190 
      if ftype == TType.STOP:
27191 
        break
27192 
      if fid == 1:
27193 
        if ftype == TType.I64:
27194 
          self.rechargeRrderId = iprot.readI64();
27195 
        else:
27196 
          iprot.skip(ftype)
27197 
      else:
27198 
        iprot.skip(ftype)
27199 
      iprot.readFieldEnd()
27200 
    iprot.readStructEnd()
27201 
 
27202 
  def write(self, oprot):
27203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27205 
      return
27206 
    oprot.writeStructBegin('getRechargeOrder_args')
27207 
    if self.rechargeRrderId is not None:
27208 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27209 
      oprot.writeI64(self.rechargeRrderId)
27210 
      oprot.writeFieldEnd()
27211 
    oprot.writeFieldStop()
27212 
    oprot.writeStructEnd()
27213 
 
27214 
  def validate(self):
27215 
    return
27216 
 
27217 
 
27218 
  def __repr__(self):
27219 
    L = ['%s=%r' % (key, value)
27220 
      for key, value in self.__dict__.iteritems()]
27221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27222 
 
27223 
  def __eq__(self, other):
27224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27225 
 
27226 
  def __ne__(self, other):
27227 
    return not (self == other)
27228 
 
27229 
class getRechargeOrder_result:
27230 
  """
27231 
  Attributes:
27232 
   - success
27233 
   - ex
27234 
  """
27235 
 
27236 
  thrift_spec = (
27237 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27238 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27239 
  )
27240 
 
27241 
  def __init__(self, success=None, ex=None,):
27242 
    self.success = success
27243 
    self.ex = ex
27244 
 
27245 
  def read(self, iprot):
27246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27248 
      return
27249 
    iprot.readStructBegin()
27250 
    while True:
27251 
      (fname, ftype, fid) = iprot.readFieldBegin()
27252 
      if ftype == TType.STOP:
27253 
        break
27254 
      if fid == 0:
27255 
        if ftype == TType.STRUCT:
27256 
          self.success = RechargeOrder()
27257 
          self.success.read(iprot)
27258 
        else:
27259 
          iprot.skip(ftype)
27260 
      elif fid == 1:
27261 
        if ftype == TType.STRUCT:
27262 
          self.ex = TransactionServiceException()
27263 
          self.ex.read(iprot)
27264 
        else:
27265 
          iprot.skip(ftype)
27266 
      else:
27267 
        iprot.skip(ftype)
27268 
      iprot.readFieldEnd()
27269 
    iprot.readStructEnd()
27270 
 
27271 
  def write(self, oprot):
27272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27274 
      return
27275 
    oprot.writeStructBegin('getRechargeOrder_result')
27276 
    if self.success is not None:
27277 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27278 
      self.success.write(oprot)
27279 
      oprot.writeFieldEnd()
27280 
    if self.ex is not None:
27281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27282 
      self.ex.write(oprot)
27283 
      oprot.writeFieldEnd()
27284 
    oprot.writeFieldStop()
27285 
    oprot.writeStructEnd()
27286 
 
27287 
  def validate(self):
27288 
    return
27289 
 
27290 
 
27291 
  def __repr__(self):
27292 
    L = ['%s=%r' % (key, value)
27293 
      for key, value in self.__dict__.iteritems()]
27294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27295 
 
27296 
  def __eq__(self, other):
27297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27298 
 
27299 
  def __ne__(self, other):
27300 
    return not (self == other)
27301 
 
27302 
class getRechargeOrders_args:
27303 
  """
27304 
  Attributes:
27305 
   - userId
27306 
  """
27307 
 
27308 
  thrift_spec = (
27309 
    None, # 0
27310 
    (1, TType.I64, 'userId', None, None, ), # 1
27311 
  )
27312 
 
27313 
  def __init__(self, userId=None,):
27314 
    self.userId = userId
27315 
 
27316 
  def read(self, iprot):
27317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27319 
      return
27320 
    iprot.readStructBegin()
27321 
    while True:
27322 
      (fname, ftype, fid) = iprot.readFieldBegin()
27323 
      if ftype == TType.STOP:
27324 
        break
27325 
      if fid == 1:
27326 
        if ftype == TType.I64:
27327 
          self.userId = iprot.readI64();
27328 
        else:
27329 
          iprot.skip(ftype)
27330 
      else:
27331 
        iprot.skip(ftype)
27332 
      iprot.readFieldEnd()
27333 
    iprot.readStructEnd()
27334 
 
27335 
  def write(self, oprot):
27336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27338 
      return
27339 
    oprot.writeStructBegin('getRechargeOrders_args')
27340 
    if self.userId is not None:
27341 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27342 
      oprot.writeI64(self.userId)
27343 
      oprot.writeFieldEnd()
27344 
    oprot.writeFieldStop()
27345 
    oprot.writeStructEnd()
27346 
 
27347 
  def validate(self):
27348 
    return
27349 
 
27350 
 
27351 
  def __repr__(self):
27352 
    L = ['%s=%r' % (key, value)
27353 
      for key, value in self.__dict__.iteritems()]
27354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27355 
 
27356 
  def __eq__(self, other):
27357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27358 
 
27359 
  def __ne__(self, other):
27360 
    return not (self == other)
27361 
 
27362 
class getRechargeOrders_result:
27363 
  """
27364 
  Attributes:
27365 
   - success
27366 
  """
27367 
 
27368 
  thrift_spec = (
27369 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27370 
  )
27371 
 
27372 
  def __init__(self, success=None,):
27373 
    self.success = success
27374 
 
27375 
  def read(self, iprot):
27376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27378 
      return
27379 
    iprot.readStructBegin()
27380 
    while True:
27381 
      (fname, ftype, fid) = iprot.readFieldBegin()
27382 
      if ftype == TType.STOP:
27383 
        break
27384 
      if fid == 0:
27385 
        if ftype == TType.LIST:
27386 
          self.success = []
6188 rajveer 27387 
          (_etype659, _size656) = iprot.readListBegin()
27388 
          for _i660 in xrange(_size656):
27389 
            _elem661 = RechargeOrder()
27390 
            _elem661.read(iprot)
27391 
            self.success.append(_elem661)
6031 rajveer 27392 
          iprot.readListEnd()
27393 
        else:
27394 
          iprot.skip(ftype)
27395 
      else:
27396 
        iprot.skip(ftype)
27397 
      iprot.readFieldEnd()
27398 
    iprot.readStructEnd()
27399 
 
27400 
  def write(self, oprot):
27401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27403 
      return
27404 
    oprot.writeStructBegin('getRechargeOrders_result')
27405 
    if self.success is not None:
27406 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27407 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27408 
      for iter662 in self.success:
27409 
        iter662.write(oprot)
6031 rajveer 27410 
      oprot.writeListEnd()
27411 
      oprot.writeFieldEnd()
27412 
    oprot.writeFieldStop()
27413 
    oprot.writeStructEnd()
27414 
 
27415 
  def validate(self):
27416 
    return
27417 
 
27418 
 
27419 
  def __repr__(self):
27420 
    L = ['%s=%r' % (key, value)
27421 
      for key, value in self.__dict__.iteritems()]
27422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27423 
 
27424 
  def __eq__(self, other):
27425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27426 
 
27427 
  def __ne__(self, other):
27428 
    return not (self == other)
27429 
 
6000 mandeep.dh 27430 
class updateRechargeOrderStatus_args:
27431 
  """
27432 
  Attributes:
27433 
   - rechargeOrderId
27434 
   - rechargeOrderStatus
27435 
  """
27436 
 
27437 
  thrift_spec = (
27438 
    None, # 0
27439 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27440 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27441 
  )
27442 
 
27443 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27444 
    self.rechargeOrderId = rechargeOrderId
27445 
    self.rechargeOrderStatus = rechargeOrderStatus
27446 
 
27447 
  def read(self, iprot):
27448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27450 
      return
27451 
    iprot.readStructBegin()
27452 
    while True:
27453 
      (fname, ftype, fid) = iprot.readFieldBegin()
27454 
      if ftype == TType.STOP:
27455 
        break
27456 
      if fid == 1:
27457 
        if ftype == TType.I64:
27458 
          self.rechargeOrderId = iprot.readI64();
27459 
        else:
27460 
          iprot.skip(ftype)
27461 
      elif fid == 2:
27462 
        if ftype == TType.I32:
27463 
          self.rechargeOrderStatus = iprot.readI32();
27464 
        else:
27465 
          iprot.skip(ftype)
27466 
      else:
27467 
        iprot.skip(ftype)
27468 
      iprot.readFieldEnd()
27469 
    iprot.readStructEnd()
27470 
 
27471 
  def write(self, oprot):
27472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27474 
      return
27475 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27476 
    if self.rechargeOrderId is not None:
27477 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27478 
      oprot.writeI64(self.rechargeOrderId)
27479 
      oprot.writeFieldEnd()
27480 
    if self.rechargeOrderStatus is not None:
27481 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27482 
      oprot.writeI32(self.rechargeOrderStatus)
27483 
      oprot.writeFieldEnd()
27484 
    oprot.writeFieldStop()
27485 
    oprot.writeStructEnd()
27486 
 
27487 
  def validate(self):
27488 
    return
27489 
 
27490 
 
27491 
  def __repr__(self):
27492 
    L = ['%s=%r' % (key, value)
27493 
      for key, value in self.__dict__.iteritems()]
27494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27495 
 
27496 
  def __eq__(self, other):
27497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27498 
 
27499 
  def __ne__(self, other):
27500 
    return not (self == other)
27501 
 
27502 
class updateRechargeOrderStatus_result:
27503 
  """
27504 
  Attributes:
6031 rajveer 27505 
   - success
6000 mandeep.dh 27506 
   - ex
27507 
  """
27508 
 
27509 
  thrift_spec = (
6031 rajveer 27510 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27511 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27512 
  )
27513 
 
6031 rajveer 27514 
  def __init__(self, success=None, ex=None,):
27515 
    self.success = success
6000 mandeep.dh 27516 
    self.ex = ex
27517 
 
27518 
  def read(self, iprot):
27519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27521 
      return
27522 
    iprot.readStructBegin()
27523 
    while True:
27524 
      (fname, ftype, fid) = iprot.readFieldBegin()
27525 
      if ftype == TType.STOP:
27526 
        break
6031 rajveer 27527 
      if fid == 0:
27528 
        if ftype == TType.BOOL:
27529 
          self.success = iprot.readBool();
27530 
        else:
27531 
          iprot.skip(ftype)
27532 
      elif fid == 1:
6000 mandeep.dh 27533 
        if ftype == TType.STRUCT:
27534 
          self.ex = TransactionServiceException()
27535 
          self.ex.read(iprot)
27536 
        else:
27537 
          iprot.skip(ftype)
27538 
      else:
27539 
        iprot.skip(ftype)
27540 
      iprot.readFieldEnd()
27541 
    iprot.readStructEnd()
27542 
 
27543 
  def write(self, oprot):
27544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27546 
      return
27547 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27548 
    if self.success is not None:
27549 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27550 
      oprot.writeBool(self.success)
27551 
      oprot.writeFieldEnd()
6000 mandeep.dh 27552 
    if self.ex is not None:
27553 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27554 
      self.ex.write(oprot)
27555 
      oprot.writeFieldEnd()
27556 
    oprot.writeFieldStop()
27557 
    oprot.writeStructEnd()
27558 
 
27559 
  def validate(self):
27560 
    return
27561 
 
27562 
 
27563 
  def __repr__(self):
27564 
    L = ['%s=%r' % (key, value)
27565 
      for key, value in self.__dict__.iteritems()]
27566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27567 
 
27568 
  def __eq__(self, other):
27569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27570 
 
27571 
  def __ne__(self, other):
27572 
    return not (self == other)
27573 
 
27574 
class activateRechargeTxn_args:
27575 
  """
27576 
  Attributes:
6031 rajveer 27577 
   - rechargeOrderId
6000 mandeep.dh 27578 
  """
27579 
 
27580 
  thrift_spec = (
27581 
    None, # 0
6031 rajveer 27582 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27583 
  )
27584 
 
6031 rajveer 27585 
  def __init__(self, rechargeOrderId=None,):
27586 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27587 
 
27588 
  def read(self, iprot):
27589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27591 
      return
27592 
    iprot.readStructBegin()
27593 
    while True:
27594 
      (fname, ftype, fid) = iprot.readFieldBegin()
27595 
      if ftype == TType.STOP:
27596 
        break
27597 
      if fid == 1:
6031 rajveer 27598 
        if ftype == TType.I64:
27599 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27600 
        else:
27601 
          iprot.skip(ftype)
27602 
      else:
27603 
        iprot.skip(ftype)
27604 
      iprot.readFieldEnd()
27605 
    iprot.readStructEnd()
27606 
 
27607 
  def write(self, oprot):
27608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27610 
      return
27611 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27612 
    if self.rechargeOrderId is not None:
27613 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27614 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27615 
      oprot.writeFieldEnd()
27616 
    oprot.writeFieldStop()
27617 
    oprot.writeStructEnd()
27618 
 
27619 
  def validate(self):
27620 
    return
27621 
 
27622 
 
27623 
  def __repr__(self):
27624 
    L = ['%s=%r' % (key, value)
27625 
      for key, value in self.__dict__.iteritems()]
27626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27627 
 
27628 
  def __eq__(self, other):
27629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27630 
 
27631 
  def __ne__(self, other):
27632 
    return not (self == other)
27633 
 
27634 
class activateRechargeTxn_result:
27635 
  """
27636 
  Attributes:
27637 
   - success
27638 
   - ex
27639 
  """
27640 
 
27641 
  thrift_spec = (
6031 rajveer 27642 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27643 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27644 
  )
27645 
 
27646 
  def __init__(self, success=None, ex=None,):
27647 
    self.success = success
27648 
    self.ex = ex
27649 
 
27650 
  def read(self, iprot):
27651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27653 
      return
27654 
    iprot.readStructBegin()
27655 
    while True:
27656 
      (fname, ftype, fid) = iprot.readFieldBegin()
27657 
      if ftype == TType.STOP:
27658 
        break
27659 
      if fid == 0:
6031 rajveer 27660 
        if ftype == TType.BOOL:
27661 
          self.success = iprot.readBool();
6000 mandeep.dh 27662 
        else:
27663 
          iprot.skip(ftype)
27664 
      elif fid == 1:
27665 
        if ftype == TType.STRUCT:
27666 
          self.ex = TransactionServiceException()
27667 
          self.ex.read(iprot)
27668 
        else:
27669 
          iprot.skip(ftype)
27670 
      else:
27671 
        iprot.skip(ftype)
27672 
      iprot.readFieldEnd()
27673 
    iprot.readStructEnd()
27674 
 
27675 
  def write(self, oprot):
27676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27678 
      return
27679 
    oprot.writeStructBegin('activateRechargeTxn_result')
27680 
    if self.success is not None:
6031 rajveer 27681 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27682 
      oprot.writeBool(self.success)
6000 mandeep.dh 27683 
      oprot.writeFieldEnd()
27684 
    if self.ex is not None:
27685 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27686 
      self.ex.write(oprot)
27687 
      oprot.writeFieldEnd()
27688 
    oprot.writeFieldStop()
27689 
    oprot.writeStructEnd()
27690 
 
27691 
  def validate(self):
27692 
    return
27693 
 
27694 
 
27695 
  def __repr__(self):
27696 
    L = ['%s=%r' % (key, value)
27697 
      for key, value in self.__dict__.iteritems()]
27698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27699 
 
27700 
  def __eq__(self, other):
27701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27702 
 
27703 
  def __ne__(self, other):
27704 
    return not (self == other)
27705 
 
6031 rajveer 27706 
class getUserWallet_args:
6000 mandeep.dh 27707 
  """
27708 
  Attributes:
6031 rajveer 27709 
   - userId
6000 mandeep.dh 27710 
  """
27711 
 
27712 
  thrift_spec = (
27713 
    None, # 0
6031 rajveer 27714 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27715 
  )
27716 
 
6031 rajveer 27717 
  def __init__(self, userId=None,):
27718 
    self.userId = userId
6000 mandeep.dh 27719 
 
27720 
  def read(self, iprot):
27721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27723 
      return
27724 
    iprot.readStructBegin()
27725 
    while True:
27726 
      (fname, ftype, fid) = iprot.readFieldBegin()
27727 
      if ftype == TType.STOP:
27728 
        break
27729 
      if fid == 1:
27730 
        if ftype == TType.I64:
6031 rajveer 27731 
          self.userId = iprot.readI64();
6000 mandeep.dh 27732 
        else:
27733 
          iprot.skip(ftype)
27734 
      else:
27735 
        iprot.skip(ftype)
27736 
      iprot.readFieldEnd()
27737 
    iprot.readStructEnd()
27738 
 
27739 
  def write(self, oprot):
27740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27742 
      return
6031 rajveer 27743 
    oprot.writeStructBegin('getUserWallet_args')
27744 
    if self.userId is not None:
27745 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27746 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27747 
      oprot.writeFieldEnd()
27748 
    oprot.writeFieldStop()
27749 
    oprot.writeStructEnd()
27750 
 
27751 
  def validate(self):
27752 
    return
27753 
 
27754 
 
27755 
  def __repr__(self):
27756 
    L = ['%s=%r' % (key, value)
27757 
      for key, value in self.__dict__.iteritems()]
27758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27759 
 
27760 
  def __eq__(self, other):
27761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27762 
 
27763 
  def __ne__(self, other):
27764 
    return not (self == other)
27765 
 
6031 rajveer 27766 
class getUserWallet_result:
6000 mandeep.dh 27767 
  """
27768 
  Attributes:
27769 
   - success
27770 
  """
27771 
 
27772 
  thrift_spec = (
6031 rajveer 27773 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27774 
  )
27775 
 
27776 
  def __init__(self, success=None,):
27777 
    self.success = success
27778 
 
27779 
  def read(self, iprot):
27780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27782 
      return
27783 
    iprot.readStructBegin()
27784 
    while True:
27785 
      (fname, ftype, fid) = iprot.readFieldBegin()
27786 
      if ftype == TType.STOP:
27787 
        break
27788 
      if fid == 0:
6031 rajveer 27789 
        if ftype == TType.STRUCT:
27790 
          self.success = UserWallet()
27791 
          self.success.read(iprot)
6000 mandeep.dh 27792 
        else:
27793 
          iprot.skip(ftype)
27794 
      else:
27795 
        iprot.skip(ftype)
27796 
      iprot.readFieldEnd()
27797 
    iprot.readStructEnd()
27798 
 
27799 
  def write(self, oprot):
27800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27802 
      return
6031 rajveer 27803 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27804 
    if self.success is not None:
6031 rajveer 27805 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27806 
      self.success.write(oprot)
6000 mandeep.dh 27807 
      oprot.writeFieldEnd()
27808 
    oprot.writeFieldStop()
27809 
    oprot.writeStructEnd()
27810 
 
27811 
  def validate(self):
27812 
    return
27813 
 
27814 
 
27815 
  def __repr__(self):
27816 
    L = ['%s=%r' % (key, value)
27817 
      for key, value in self.__dict__.iteritems()]
27818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27819 
 
27820 
  def __eq__(self, other):
27821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27822 
 
27823 
  def __ne__(self, other):
27824 
    return not (self == other)
27825 
 
6031 rajveer 27826 
class getUserWalletHistory_args:
6000 mandeep.dh 27827 
  """
27828 
  Attributes:
6031 rajveer 27829 
   - userId
6000 mandeep.dh 27830 
  """
27831 
 
27832 
  thrift_spec = (
27833 
    None, # 0
6031 rajveer 27834 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27835 
  )
27836 
 
6031 rajveer 27837 
  def __init__(self, userId=None,):
27838 
    self.userId = userId
6000 mandeep.dh 27839 
 
27840 
  def read(self, iprot):
27841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27843 
      return
27844 
    iprot.readStructBegin()
27845 
    while True:
27846 
      (fname, ftype, fid) = iprot.readFieldBegin()
27847 
      if ftype == TType.STOP:
27848 
        break
27849 
      if fid == 1:
27850 
        if ftype == TType.I64:
6031 rajveer 27851 
          self.userId = iprot.readI64();
6000 mandeep.dh 27852 
        else:
27853 
          iprot.skip(ftype)
27854 
      else:
27855 
        iprot.skip(ftype)
27856 
      iprot.readFieldEnd()
27857 
    iprot.readStructEnd()
27858 
 
27859 
  def write(self, oprot):
27860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27862 
      return
6031 rajveer 27863 
    oprot.writeStructBegin('getUserWalletHistory_args')
27864 
    if self.userId is not None:
27865 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27866 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27867 
      oprot.writeFieldEnd()
27868 
    oprot.writeFieldStop()
27869 
    oprot.writeStructEnd()
27870 
 
27871 
  def validate(self):
27872 
    return
27873 
 
27874 
 
27875 
  def __repr__(self):
27876 
    L = ['%s=%r' % (key, value)
27877 
      for key, value in self.__dict__.iteritems()]
27878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27879 
 
27880 
  def __eq__(self, other):
27881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27882 
 
27883 
  def __ne__(self, other):
27884 
    return not (self == other)
27885 
 
6031 rajveer 27886 
class getUserWalletHistory_result:
6000 mandeep.dh 27887 
  """
27888 
  Attributes:
27889 
   - success
27890 
  """
27891 
 
27892 
  thrift_spec = (
6031 rajveer 27893 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27894 
  )
27895 
 
27896 
  def __init__(self, success=None,):
27897 
    self.success = success
27898 
 
27899 
  def read(self, iprot):
27900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27902 
      return
27903 
    iprot.readStructBegin()
27904 
    while True:
27905 
      (fname, ftype, fid) = iprot.readFieldBegin()
27906 
      if ftype == TType.STOP:
27907 
        break
27908 
      if fid == 0:
27909 
        if ftype == TType.LIST:
27910 
          self.success = []
6188 rajveer 27911 
          (_etype666, _size663) = iprot.readListBegin()
27912 
          for _i667 in xrange(_size663):
27913 
            _elem668 = UserWalletHistory()
27914 
            _elem668.read(iprot)
27915 
            self.success.append(_elem668)
6000 mandeep.dh 27916 
          iprot.readListEnd()
27917 
        else:
27918 
          iprot.skip(ftype)
27919 
      else:
27920 
        iprot.skip(ftype)
27921 
      iprot.readFieldEnd()
27922 
    iprot.readStructEnd()
27923 
 
27924 
  def write(self, oprot):
27925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27927 
      return
6031 rajveer 27928 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27929 
    if self.success is not None:
27930 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27931 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27932 
      for iter669 in self.success:
27933 
        iter669.write(oprot)
6000 mandeep.dh 27934 
      oprot.writeListEnd()
27935 
      oprot.writeFieldEnd()
27936 
    oprot.writeFieldStop()
27937 
    oprot.writeStructEnd()
27938 
 
27939 
  def validate(self):
27940 
    return
27941 
 
27942 
 
27943 
  def __repr__(self):
27944 
    L = ['%s=%r' % (key, value)
27945 
      for key, value in self.__dict__.iteritems()]
27946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27947 
 
27948 
  def __eq__(self, other):
27949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27950 
 
27951 
  def __ne__(self, other):
27952 
    return not (self == other)
6048 rajveer 27953 
 
6050 anupam.sin 27954 
class getRechargeOrdersForTransaction_args:
27955 
  """
27956 
  Attributes:
27957 
   - txnId
27958 
  """
27959 
 
27960 
  thrift_spec = (
27961 
    None, # 0
27962 
    (1, TType.I64, 'txnId', None, None, ), # 1
27963 
  )
27964 
 
27965 
  def __init__(self, txnId=None,):
27966 
    self.txnId = txnId
27967 
 
27968 
  def read(self, iprot):
27969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27971 
      return
27972 
    iprot.readStructBegin()
27973 
    while True:
27974 
      (fname, ftype, fid) = iprot.readFieldBegin()
27975 
      if ftype == TType.STOP:
27976 
        break
27977 
      if fid == 1:
27978 
        if ftype == TType.I64:
27979 
          self.txnId = iprot.readI64();
27980 
        else:
27981 
          iprot.skip(ftype)
27982 
      else:
27983 
        iprot.skip(ftype)
27984 
      iprot.readFieldEnd()
27985 
    iprot.readStructEnd()
27986 
 
27987 
  def write(self, oprot):
27988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27990 
      return
27991 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27992 
    if self.txnId is not None:
27993 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27994 
      oprot.writeI64(self.txnId)
27995 
      oprot.writeFieldEnd()
27996 
    oprot.writeFieldStop()
27997 
    oprot.writeStructEnd()
27998 
 
27999 
  def validate(self):
28000 
    return
28001 
 
28002 
 
28003 
  def __repr__(self):
28004 
    L = ['%s=%r' % (key, value)
28005 
      for key, value in self.__dict__.iteritems()]
28006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28007 
 
28008 
  def __eq__(self, other):
28009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28010 
 
28011 
  def __ne__(self, other):
28012 
    return not (self == other)
28013 
 
28014 
class getRechargeOrdersForTransaction_result:
28015 
  """
28016 
  Attributes:
28017 
   - success
28018 
   - ex
28019 
  """
28020 
 
28021 
  thrift_spec = (
28022 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28024 
  )
28025 
 
28026 
  def __init__(self, success=None, ex=None,):
28027 
    self.success = success
28028 
    self.ex = ex
28029 
 
28030 
  def read(self, iprot):
28031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28033 
      return
28034 
    iprot.readStructBegin()
28035 
    while True:
28036 
      (fname, ftype, fid) = iprot.readFieldBegin()
28037 
      if ftype == TType.STOP:
28038 
        break
28039 
      if fid == 0:
28040 
        if ftype == TType.STRUCT:
28041 
          self.success = RechargeOrder()
28042 
          self.success.read(iprot)
28043 
        else:
28044 
          iprot.skip(ftype)
28045 
      elif fid == 1:
28046 
        if ftype == TType.STRUCT:
28047 
          self.ex = TransactionServiceException()
28048 
          self.ex.read(iprot)
28049 
        else:
28050 
          iprot.skip(ftype)
28051 
      else:
28052 
        iprot.skip(ftype)
28053 
      iprot.readFieldEnd()
28054 
    iprot.readStructEnd()
28055 
 
28056 
  def write(self, oprot):
28057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28059 
      return
28060 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28061 
    if self.success is not None:
28062 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28063 
      self.success.write(oprot)
28064 
      oprot.writeFieldEnd()
28065 
    if self.ex is not None:
28066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28067 
      self.ex.write(oprot)
28068 
      oprot.writeFieldEnd()
28069 
    oprot.writeFieldStop()
28070 
    oprot.writeStructEnd()
28071 
 
28072 
  def validate(self):
28073 
    return
28074 
 
28075 
 
28076 
  def __repr__(self):
28077 
    L = ['%s=%r' % (key, value)
28078 
      for key, value in self.__dict__.iteritems()]
28079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28080 
 
28081 
  def __eq__(self, other):
28082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28083 
 
28084 
  def __ne__(self, other):
28085 
    return not (self == other)
28086 
 
6048 rajveer 28087 
class getServiceProviders_args:
28088 
  """
28089 
  Attributes:
28090 
   - rechargeType
6206 rajveer 28091 
   - onlyActive
6048 rajveer 28092 
  """
28093 
 
28094 
  thrift_spec = (
28095 
    None, # 0
28096 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28097 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28098 
  )
28099 
 
6206 rajveer 28100 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28101 
    self.rechargeType = rechargeType
6206 rajveer 28102 
    self.onlyActive = onlyActive
6048 rajveer 28103 
 
28104 
  def read(self, iprot):
28105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28107 
      return
28108 
    iprot.readStructBegin()
28109 
    while True:
28110 
      (fname, ftype, fid) = iprot.readFieldBegin()
28111 
      if ftype == TType.STOP:
28112 
        break
28113 
      if fid == 1:
28114 
        if ftype == TType.I32:
28115 
          self.rechargeType = iprot.readI32();
28116 
        else:
28117 
          iprot.skip(ftype)
6206 rajveer 28118 
      elif fid == 2:
28119 
        if ftype == TType.BOOL:
28120 
          self.onlyActive = iprot.readBool();
28121 
        else:
28122 
          iprot.skip(ftype)
6048 rajveer 28123 
      else:
28124 
        iprot.skip(ftype)
28125 
      iprot.readFieldEnd()
28126 
    iprot.readStructEnd()
28127 
 
28128 
  def write(self, oprot):
28129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28131 
      return
28132 
    oprot.writeStructBegin('getServiceProviders_args')
28133 
    if self.rechargeType is not None:
28134 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28135 
      oprot.writeI32(self.rechargeType)
28136 
      oprot.writeFieldEnd()
6206 rajveer 28137 
    if self.onlyActive is not None:
28138 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28139 
      oprot.writeBool(self.onlyActive)
28140 
      oprot.writeFieldEnd()
6048 rajveer 28141 
    oprot.writeFieldStop()
28142 
    oprot.writeStructEnd()
28143 
 
28144 
  def validate(self):
28145 
    return
28146 
 
28147 
 
28148 
  def __repr__(self):
28149 
    L = ['%s=%r' % (key, value)
28150 
      for key, value in self.__dict__.iteritems()]
28151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28152 
 
28153 
  def __eq__(self, other):
28154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28155 
 
28156 
  def __ne__(self, other):
28157 
    return not (self == other)
28158 
 
28159 
class getServiceProviders_result:
28160 
  """
28161 
  Attributes:
28162 
   - success
28163 
  """
28164 
 
28165 
  thrift_spec = (
28166 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28167 
  )
28168 
 
28169 
  def __init__(self, success=None,):
28170 
    self.success = success
28171 
 
28172 
  def read(self, iprot):
28173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28175 
      return
28176 
    iprot.readStructBegin()
28177 
    while True:
28178 
      (fname, ftype, fid) = iprot.readFieldBegin()
28179 
      if ftype == TType.STOP:
28180 
        break
28181 
      if fid == 0:
28182 
        if ftype == TType.MAP:
28183 
          self.success = {}
6188 rajveer 28184 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28185 
          for _i674 in xrange(_size670):
28186 
            _key675 = iprot.readI64();
28187 
            _val676 = iprot.readString();
28188 
            self.success[_key675] = _val676
6048 rajveer 28189 
          iprot.readMapEnd()
28190 
        else:
28191 
          iprot.skip(ftype)
28192 
      else:
28193 
        iprot.skip(ftype)
28194 
      iprot.readFieldEnd()
28195 
    iprot.readStructEnd()
28196 
 
28197 
  def write(self, oprot):
28198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28200 
      return
28201 
    oprot.writeStructBegin('getServiceProviders_result')
28202 
    if self.success is not None:
28203 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28204 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28205 
      for kiter677,viter678 in self.success.items():
28206 
        oprot.writeI64(kiter677)
28207 
        oprot.writeString(viter678)
6048 rajveer 28208 
      oprot.writeMapEnd()
28209 
      oprot.writeFieldEnd()
28210 
    oprot.writeFieldStop()
28211 
    oprot.writeStructEnd()
28212 
 
28213 
  def validate(self):
28214 
    return
28215 
 
28216 
 
28217 
  def __repr__(self):
28218 
    L = ['%s=%r' % (key, value)
28219 
      for key, value in self.__dict__.iteritems()]
28220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28221 
 
28222 
  def __eq__(self, other):
28223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28224 
 
28225 
  def __ne__(self, other):
28226 
    return not (self == other)
28227 
 
28228 
class getServiceProviderForDevice_args:
28229 
  """
28230 
  Attributes:
6049 rajveer 28231 
   - rechargeType
6048 rajveer 28232 
   - deviceNumber
28233 
  """
28234 
 
28235 
  thrift_spec = (
28236 
    None, # 0
6049 rajveer 28237 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28238 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28239 
  )
28240 
 
6049 rajveer 28241 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28242 
    self.rechargeType = rechargeType
6048 rajveer 28243 
    self.deviceNumber = deviceNumber
28244 
 
28245 
  def read(self, iprot):
28246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28248 
      return
28249 
    iprot.readStructBegin()
28250 
    while True:
28251 
      (fname, ftype, fid) = iprot.readFieldBegin()
28252 
      if ftype == TType.STOP:
28253 
        break
28254 
      if fid == 1:
6049 rajveer 28255 
        if ftype == TType.I32:
28256 
          self.rechargeType = iprot.readI32();
28257 
        else:
28258 
          iprot.skip(ftype)
28259 
      elif fid == 2:
6048 rajveer 28260 
        if ftype == TType.STRING:
28261 
          self.deviceNumber = iprot.readString();
28262 
        else:
28263 
          iprot.skip(ftype)
28264 
      else:
28265 
        iprot.skip(ftype)
28266 
      iprot.readFieldEnd()
28267 
    iprot.readStructEnd()
28268 
 
28269 
  def write(self, oprot):
28270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28272 
      return
28273 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28274 
    if self.rechargeType is not None:
28275 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28276 
      oprot.writeI32(self.rechargeType)
28277 
      oprot.writeFieldEnd()
6048 rajveer 28278 
    if self.deviceNumber is not None:
6049 rajveer 28279 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28280 
      oprot.writeString(self.deviceNumber)
28281 
      oprot.writeFieldEnd()
28282 
    oprot.writeFieldStop()
28283 
    oprot.writeStructEnd()
28284 
 
28285 
  def validate(self):
28286 
    return
28287 
 
28288 
 
28289 
  def __repr__(self):
28290 
    L = ['%s=%r' % (key, value)
28291 
      for key, value in self.__dict__.iteritems()]
28292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28293 
 
28294 
  def __eq__(self, other):
28295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28296 
 
28297 
  def __ne__(self, other):
28298 
    return not (self == other)
28299 
 
28300 
class getServiceProviderForDevice_result:
28301 
  """
28302 
  Attributes:
28303 
   - success
28304 
  """
28305 
 
28306 
  thrift_spec = (
6289 anupam.sin 28307 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28308 
  )
28309 
 
28310 
  def __init__(self, success=None,):
28311 
    self.success = success
28312 
 
28313 
  def read(self, iprot):
28314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28316 
      return
28317 
    iprot.readStructBegin()
28318 
    while True:
28319 
      (fname, ftype, fid) = iprot.readFieldBegin()
28320 
      if ftype == TType.STOP:
28321 
        break
28322 
      if fid == 0:
6289 anupam.sin 28323 
        if ftype == TType.STRUCT:
28324 
          self.success = DeviceNumberInfo()
28325 
          self.success.read(iprot)
6048 rajveer 28326 
        else:
28327 
          iprot.skip(ftype)
28328 
      else:
28329 
        iprot.skip(ftype)
28330 
      iprot.readFieldEnd()
28331 
    iprot.readStructEnd()
28332 
 
28333 
  def write(self, oprot):
28334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28336 
      return
28337 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28338 
    if self.success is not None:
6289 anupam.sin 28339 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28340 
      self.success.write(oprot)
6048 rajveer 28341 
      oprot.writeFieldEnd()
28342 
    oprot.writeFieldStop()
28343 
    oprot.writeStructEnd()
28344 
 
28345 
  def validate(self):
28346 
    return
28347 
 
28348 
 
28349 
  def __repr__(self):
28350 
    L = ['%s=%r' % (key, value)
28351 
      for key, value in self.__dict__.iteritems()]
28352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28353 
 
28354 
  def __eq__(self, other):
28355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28356 
 
28357 
  def __ne__(self, other):
28358 
    return not (self == other)
6094 rajveer 28359 
 
6269 rajveer 28360 
class validateRecharge_args:
28361 
  """
28362 
  Attributes:
28363 
   - rechargeType
28364 
   - deviceNumber
6307 anupam.sin 28365 
   - userSelectedProviderId
6591 anupam.sin 28366 
   - clientAddress
6269 rajveer 28367 
  """
28368 
 
28369 
  thrift_spec = (
28370 
    None, # 0
28371 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28372 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28373 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28374 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28375 
  )
28376 
 
6591 anupam.sin 28377 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28378 
    self.rechargeType = rechargeType
28379 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28380 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28381 
    self.clientAddress = clientAddress
6269 rajveer 28382 
 
28383 
  def read(self, iprot):
28384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28386 
      return
28387 
    iprot.readStructBegin()
28388 
    while True:
28389 
      (fname, ftype, fid) = iprot.readFieldBegin()
28390 
      if ftype == TType.STOP:
28391 
        break
28392 
      if fid == 1:
28393 
        if ftype == TType.I32:
28394 
          self.rechargeType = iprot.readI32();
28395 
        else:
28396 
          iprot.skip(ftype)
28397 
      elif fid == 2:
28398 
        if ftype == TType.STRING:
28399 
          self.deviceNumber = iprot.readString();
28400 
        else:
28401 
          iprot.skip(ftype)
6307 anupam.sin 28402 
      elif fid == 3:
28403 
        if ftype == TType.I64:
28404 
          self.userSelectedProviderId = iprot.readI64();
28405 
        else:
28406 
          iprot.skip(ftype)
6591 anupam.sin 28407 
      elif fid == 4:
28408 
        if ftype == TType.STRING:
28409 
          self.clientAddress = iprot.readString();
28410 
        else:
28411 
          iprot.skip(ftype)
6269 rajveer 28412 
      else:
28413 
        iprot.skip(ftype)
28414 
      iprot.readFieldEnd()
28415 
    iprot.readStructEnd()
28416 
 
28417 
  def write(self, oprot):
28418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28420 
      return
28421 
    oprot.writeStructBegin('validateRecharge_args')
28422 
    if self.rechargeType is not None:
28423 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28424 
      oprot.writeI32(self.rechargeType)
28425 
      oprot.writeFieldEnd()
28426 
    if self.deviceNumber is not None:
28427 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28428 
      oprot.writeString(self.deviceNumber)
28429 
      oprot.writeFieldEnd()
6307 anupam.sin 28430 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28431 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28432 
      oprot.writeI64(self.userSelectedProviderId)
28433 
      oprot.writeFieldEnd()
6591 anupam.sin 28434 
    if self.clientAddress is not None:
28435 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28436 
      oprot.writeString(self.clientAddress)
28437 
      oprot.writeFieldEnd()
6269 rajveer 28438 
    oprot.writeFieldStop()
28439 
    oprot.writeStructEnd()
28440 
 
28441 
  def validate(self):
28442 
    return
28443 
 
28444 
 
28445 
  def __repr__(self):
28446 
    L = ['%s=%r' % (key, value)
28447 
      for key, value in self.__dict__.iteritems()]
28448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28449 
 
28450 
  def __eq__(self, other):
28451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28452 
 
28453 
  def __ne__(self, other):
28454 
    return not (self == other)
28455 
 
28456 
class validateRecharge_result:
28457 
  """
28458 
  Attributes:
28459 
   - success
28460 
  """
28461 
 
28462 
  thrift_spec = (
28463 
    (0, TType.STRING, 'success', None, None, ), # 0
28464 
  )
28465 
 
28466 
  def __init__(self, success=None,):
28467 
    self.success = success
28468 
 
28469 
  def read(self, iprot):
28470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28472 
      return
28473 
    iprot.readStructBegin()
28474 
    while True:
28475 
      (fname, ftype, fid) = iprot.readFieldBegin()
28476 
      if ftype == TType.STOP:
28477 
        break
28478 
      if fid == 0:
28479 
        if ftype == TType.STRING:
28480 
          self.success = iprot.readString();
28481 
        else:
28482 
          iprot.skip(ftype)
28483 
      else:
28484 
        iprot.skip(ftype)
28485 
      iprot.readFieldEnd()
28486 
    iprot.readStructEnd()
28487 
 
28488 
  def write(self, oprot):
28489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28491 
      return
28492 
    oprot.writeStructBegin('validateRecharge_result')
28493 
    if self.success is not None:
28494 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28495 
      oprot.writeString(self.success)
28496 
      oprot.writeFieldEnd()
28497 
    oprot.writeFieldStop()
28498 
    oprot.writeStructEnd()
28499 
 
28500 
  def validate(self):
28501 
    return
28502 
 
28503 
 
28504 
  def __repr__(self):
28505 
    L = ['%s=%r' % (key, value)
28506 
      for key, value in self.__dict__.iteritems()]
28507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28508 
 
28509 
  def __eq__(self, other):
28510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28511 
 
28512 
  def __ne__(self, other):
28513 
    return not (self == other)
28514 
 
6094 rajveer 28515 
class getRechargeOrdersForDevice_args:
28516 
  """
28517 
  Attributes:
28518 
   - deviceNumber
28519 
  """
28520 
 
28521 
  thrift_spec = (
28522 
    None, # 0
28523 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28524 
  )
28525 
 
28526 
  def __init__(self, deviceNumber=None,):
28527 
    self.deviceNumber = deviceNumber
28528 
 
28529 
  def read(self, iprot):
28530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28532 
      return
28533 
    iprot.readStructBegin()
28534 
    while True:
28535 
      (fname, ftype, fid) = iprot.readFieldBegin()
28536 
      if ftype == TType.STOP:
28537 
        break
28538 
      if fid == 1:
28539 
        if ftype == TType.STRING:
28540 
          self.deviceNumber = iprot.readString();
28541 
        else:
28542 
          iprot.skip(ftype)
28543 
      else:
28544 
        iprot.skip(ftype)
28545 
      iprot.readFieldEnd()
28546 
    iprot.readStructEnd()
28547 
 
28548 
  def write(self, oprot):
28549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28551 
      return
28552 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28553 
    if self.deviceNumber is not None:
28554 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28555 
      oprot.writeString(self.deviceNumber)
28556 
      oprot.writeFieldEnd()
28557 
    oprot.writeFieldStop()
28558 
    oprot.writeStructEnd()
28559 
 
28560 
  def validate(self):
28561 
    return
28562 
 
28563 
 
28564 
  def __repr__(self):
28565 
    L = ['%s=%r' % (key, value)
28566 
      for key, value in self.__dict__.iteritems()]
28567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28568 
 
28569 
  def __eq__(self, other):
28570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28571 
 
28572 
  def __ne__(self, other):
28573 
    return not (self == other)
28574 
 
28575 
class getRechargeOrdersForDevice_result:
28576 
  """
28577 
  Attributes:
28578 
   - success
28579 
  """
28580 
 
28581 
  thrift_spec = (
28582 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28583 
  )
28584 
 
28585 
  def __init__(self, success=None,):
28586 
    self.success = success
28587 
 
28588 
  def read(self, iprot):
28589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28591 
      return
28592 
    iprot.readStructBegin()
28593 
    while True:
28594 
      (fname, ftype, fid) = iprot.readFieldBegin()
28595 
      if ftype == TType.STOP:
28596 
        break
28597 
      if fid == 0:
28598 
        if ftype == TType.LIST:
28599 
          self.success = []
6188 rajveer 28600 
          (_etype682, _size679) = iprot.readListBegin()
28601 
          for _i683 in xrange(_size679):
28602 
            _elem684 = RechargeOrder()
28603 
            _elem684.read(iprot)
28604 
            self.success.append(_elem684)
6094 rajveer 28605 
          iprot.readListEnd()
28606 
        else:
28607 
          iprot.skip(ftype)
28608 
      else:
28609 
        iprot.skip(ftype)
28610 
      iprot.readFieldEnd()
28611 
    iprot.readStructEnd()
28612 
 
28613 
  def write(self, oprot):
28614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28616 
      return
28617 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28618 
    if self.success is not None:
28619 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28620 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28621 
      for iter685 in self.success:
28622 
        iter685.write(oprot)
6094 rajveer 28623 
      oprot.writeListEnd()
28624 
      oprot.writeFieldEnd()
28625 
    oprot.writeFieldStop()
28626 
    oprot.writeStructEnd()
28627 
 
28628 
  def validate(self):
28629 
    return
28630 
 
28631 
 
28632 
  def __repr__(self):
28633 
    L = ['%s=%r' % (key, value)
28634 
      for key, value in self.__dict__.iteritems()]
28635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28636 
 
28637 
  def __eq__(self, other):
28638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28639 
 
28640 
  def __ne__(self, other):
28641 
    return not (self == other)
28642 
 
28643 
class addAmountToWallet_args:
28644 
  """
28645 
  Attributes:
28646 
   - userId
28647 
   - orderId
28648 
   - amount
28649 
  """
28650 
 
28651 
  thrift_spec = (
28652 
    None, # 0
28653 
    (1, TType.I64, 'userId', None, None, ), # 1
28654 
    (2, TType.I64, 'orderId', None, None, ), # 2
28655 
    (3, TType.I64, 'amount', None, None, ), # 3
28656 
  )
28657 
 
28658 
  def __init__(self, userId=None, orderId=None, amount=None,):
28659 
    self.userId = userId
28660 
    self.orderId = orderId
28661 
    self.amount = amount
28662 
 
28663 
  def read(self, iprot):
28664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28666 
      return
28667 
    iprot.readStructBegin()
28668 
    while True:
28669 
      (fname, ftype, fid) = iprot.readFieldBegin()
28670 
      if ftype == TType.STOP:
28671 
        break
28672 
      if fid == 1:
28673 
        if ftype == TType.I64:
28674 
          self.userId = iprot.readI64();
28675 
        else:
28676 
          iprot.skip(ftype)
28677 
      elif fid == 2:
28678 
        if ftype == TType.I64:
28679 
          self.orderId = iprot.readI64();
28680 
        else:
28681 
          iprot.skip(ftype)
28682 
      elif fid == 3:
28683 
        if ftype == TType.I64:
28684 
          self.amount = iprot.readI64();
28685 
        else:
28686 
          iprot.skip(ftype)
28687 
      else:
28688 
        iprot.skip(ftype)
28689 
      iprot.readFieldEnd()
28690 
    iprot.readStructEnd()
28691 
 
28692 
  def write(self, oprot):
28693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28695 
      return
28696 
    oprot.writeStructBegin('addAmountToWallet_args')
28697 
    if self.userId is not None:
28698 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28699 
      oprot.writeI64(self.userId)
28700 
      oprot.writeFieldEnd()
28701 
    if self.orderId is not None:
28702 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28703 
      oprot.writeI64(self.orderId)
28704 
      oprot.writeFieldEnd()
28705 
    if self.amount is not None:
28706 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28707 
      oprot.writeI64(self.amount)
28708 
      oprot.writeFieldEnd()
28709 
    oprot.writeFieldStop()
28710 
    oprot.writeStructEnd()
28711 
 
28712 
  def validate(self):
28713 
    return
28714 
 
28715 
 
28716 
  def __repr__(self):
28717 
    L = ['%s=%r' % (key, value)
28718 
      for key, value in self.__dict__.iteritems()]
28719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28720 
 
28721 
  def __eq__(self, other):
28722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28723 
 
28724 
  def __ne__(self, other):
28725 
    return not (self == other)
28726 
 
28727 
class addAmountToWallet_result:
28728 
 
28729 
  thrift_spec = (
28730 
  )
28731 
 
28732 
  def read(self, iprot):
28733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28735 
      return
28736 
    iprot.readStructBegin()
28737 
    while True:
28738 
      (fname, ftype, fid) = iprot.readFieldBegin()
28739 
      if ftype == TType.STOP:
28740 
        break
28741 
      else:
28742 
        iprot.skip(ftype)
28743 
      iprot.readFieldEnd()
28744 
    iprot.readStructEnd()
28745 
 
28746 
  def write(self, oprot):
28747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28749 
      return
28750 
    oprot.writeStructBegin('addAmountToWallet_result')
28751 
    oprot.writeFieldStop()
28752 
    oprot.writeStructEnd()
28753 
 
28754 
  def validate(self):
28755 
    return
28756 
 
28757 
 
28758 
  def __repr__(self):
28759 
    L = ['%s=%r' % (key, value)
28760 
      for key, value in self.__dict__.iteritems()]
28761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28762 
 
28763 
  def __eq__(self, other):
28764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28765 
 
28766 
  def __ne__(self, other):
28767 
    return not (self == other)
6154 rajveer 28768 
 
6188 rajveer 28769 
class getRechargeStatistics_args:
28770 
 
28771 
  thrift_spec = (
28772 
  )
28773 
 
28774 
  def read(self, iprot):
28775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28777 
      return
28778 
    iprot.readStructBegin()
28779 
    while True:
28780 
      (fname, ftype, fid) = iprot.readFieldBegin()
28781 
      if ftype == TType.STOP:
28782 
        break
28783 
      else:
28784 
        iprot.skip(ftype)
28785 
      iprot.readFieldEnd()
28786 
    iprot.readStructEnd()
28787 
 
28788 
  def write(self, oprot):
28789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28791 
      return
28792 
    oprot.writeStructBegin('getRechargeStatistics_args')
28793 
    oprot.writeFieldStop()
28794 
    oprot.writeStructEnd()
28795 
 
28796 
  def validate(self):
28797 
    return
28798 
 
28799 
 
28800 
  def __repr__(self):
28801 
    L = ['%s=%r' % (key, value)
28802 
      for key, value in self.__dict__.iteritems()]
28803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28804 
 
28805 
  def __eq__(self, other):
28806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28807 
 
28808 
  def __ne__(self, other):
28809 
    return not (self == other)
28810 
 
28811 
class getRechargeStatistics_result:
28812 
  """
28813 
  Attributes:
28814 
   - success
28815 
  """
28816 
 
28817 
  thrift_spec = (
28818 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28819 
  )
28820 
 
28821 
  def __init__(self, success=None,):
28822 
    self.success = success
28823 
 
28824 
  def read(self, iprot):
28825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28827 
      return
28828 
    iprot.readStructBegin()
28829 
    while True:
28830 
      (fname, ftype, fid) = iprot.readFieldBegin()
28831 
      if ftype == TType.STOP:
28832 
        break
28833 
      if fid == 0:
28834 
        if ftype == TType.STRUCT:
28835 
          self.success = RechargeStatistics()
28836 
          self.success.read(iprot)
28837 
        else:
28838 
          iprot.skip(ftype)
28839 
      else:
28840 
        iprot.skip(ftype)
28841 
      iprot.readFieldEnd()
28842 
    iprot.readStructEnd()
28843 
 
28844 
  def write(self, oprot):
28845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28847 
      return
28848 
    oprot.writeStructBegin('getRechargeStatistics_result')
28849 
    if self.success is not None:
28850 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28851 
      self.success.write(oprot)
28852 
      oprot.writeFieldEnd()
28853 
    oprot.writeFieldStop()
28854 
    oprot.writeStructEnd()
28855 
 
28856 
  def validate(self):
28857 
    return
28858 
 
28859 
 
28860 
  def __repr__(self):
28861 
    L = ['%s=%r' % (key, value)
28862 
      for key, value in self.__dict__.iteritems()]
28863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28864 
 
28865 
  def __eq__(self, other):
28866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28867 
 
28868 
  def __ne__(self, other):
28869 
    return not (self == other)
28870 
 
6154 rajveer 28871 
class getRechargeOrdersForStatus_args:
28872 
  """
28873 
  Attributes:
28874 
   - status
28875 
  """
28876 
 
28877 
  thrift_spec = (
28878 
    None, # 0
28879 
    (1, TType.I64, 'status', None, None, ), # 1
28880 
  )
28881 
 
28882 
  def __init__(self, status=None,):
28883 
    self.status = status
28884 
 
28885 
  def read(self, iprot):
28886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28888 
      return
28889 
    iprot.readStructBegin()
28890 
    while True:
28891 
      (fname, ftype, fid) = iprot.readFieldBegin()
28892 
      if ftype == TType.STOP:
28893 
        break
28894 
      if fid == 1:
28895 
        if ftype == TType.I64:
28896 
          self.status = iprot.readI64();
28897 
        else:
28898 
          iprot.skip(ftype)
28899 
      else:
28900 
        iprot.skip(ftype)
28901 
      iprot.readFieldEnd()
28902 
    iprot.readStructEnd()
28903 
 
28904 
  def write(self, oprot):
28905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28907 
      return
28908 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28909 
    if self.status is not None:
28910 
      oprot.writeFieldBegin('status', TType.I64, 1)
28911 
      oprot.writeI64(self.status)
28912 
      oprot.writeFieldEnd()
28913 
    oprot.writeFieldStop()
28914 
    oprot.writeStructEnd()
28915 
 
28916 
  def validate(self):
28917 
    return
28918 
 
28919 
 
28920 
  def __repr__(self):
28921 
    L = ['%s=%r' % (key, value)
28922 
      for key, value in self.__dict__.iteritems()]
28923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28924 
 
28925 
  def __eq__(self, other):
28926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28927 
 
28928 
  def __ne__(self, other):
28929 
    return not (self == other)
28930 
 
28931 
class getRechargeOrdersForStatus_result:
28932 
  """
28933 
  Attributes:
28934 
   - success
28935 
  """
28936 
 
28937 
  thrift_spec = (
28938 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28939 
  )
28940 
 
28941 
  def __init__(self, success=None,):
28942 
    self.success = success
28943 
 
28944 
  def read(self, iprot):
28945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28947 
      return
28948 
    iprot.readStructBegin()
28949 
    while True:
28950 
      (fname, ftype, fid) = iprot.readFieldBegin()
28951 
      if ftype == TType.STOP:
28952 
        break
28953 
      if fid == 0:
28954 
        if ftype == TType.LIST:
28955 
          self.success = []
6188 rajveer 28956 
          (_etype689, _size686) = iprot.readListBegin()
28957 
          for _i690 in xrange(_size686):
28958 
            _elem691 = RechargeOrder()
28959 
            _elem691.read(iprot)
28960 
            self.success.append(_elem691)
6154 rajveer 28961 
          iprot.readListEnd()
28962 
        else:
28963 
          iprot.skip(ftype)
28964 
      else:
28965 
        iprot.skip(ftype)
28966 
      iprot.readFieldEnd()
28967 
    iprot.readStructEnd()
28968 
 
28969 
  def write(self, oprot):
28970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28972 
      return
28973 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28974 
    if self.success is not None:
28975 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28976 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28977 
      for iter692 in self.success:
28978 
        iter692.write(oprot)
6154 rajveer 28979 
      oprot.writeListEnd()
28980 
      oprot.writeFieldEnd()
28981 
    oprot.writeFieldStop()
28982 
    oprot.writeStructEnd()
28983 
 
28984 
  def validate(self):
28985 
    return
28986 
 
28987 
 
28988 
  def __repr__(self):
28989 
    L = ['%s=%r' % (key, value)
28990 
      for key, value in self.__dict__.iteritems()]
28991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28992 
 
28993 
  def __eq__(self, other):
28994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28995 
 
28996 
  def __ne__(self, other):
28997 
    return not (self == other)
6159 rajveer 28998 
 
28999 
class getPlansForOperator_args:
29000 
  """
29001 
  Attributes:
29002 
   - operatorId
29003 
  """
29004 
 
29005 
  thrift_spec = (
29006 
    None, # 0
29007 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29008 
  )
29009 
 
29010 
  def __init__(self, operatorId=None,):
29011 
    self.operatorId = operatorId
29012 
 
29013 
  def read(self, iprot):
29014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29016 
      return
29017 
    iprot.readStructBegin()
29018 
    while True:
29019 
      (fname, ftype, fid) = iprot.readFieldBegin()
29020 
      if ftype == TType.STOP:
29021 
        break
29022 
      if fid == 1:
29023 
        if ftype == TType.I64:
29024 
          self.operatorId = iprot.readI64();
29025 
        else:
29026 
          iprot.skip(ftype)
29027 
      else:
29028 
        iprot.skip(ftype)
29029 
      iprot.readFieldEnd()
29030 
    iprot.readStructEnd()
29031 
 
29032 
  def write(self, oprot):
29033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29035 
      return
29036 
    oprot.writeStructBegin('getPlansForOperator_args')
29037 
    if self.operatorId is not None:
29038 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29039 
      oprot.writeI64(self.operatorId)
29040 
      oprot.writeFieldEnd()
29041 
    oprot.writeFieldStop()
29042 
    oprot.writeStructEnd()
29043 
 
29044 
  def validate(self):
29045 
    return
29046 
 
29047 
 
29048 
  def __repr__(self):
29049 
    L = ['%s=%r' % (key, value)
29050 
      for key, value in self.__dict__.iteritems()]
29051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29052 
 
29053 
  def __eq__(self, other):
29054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29055 
 
29056 
  def __ne__(self, other):
29057 
    return not (self == other)
29058 
 
29059 
class getPlansForOperator_result:
29060 
  """
29061 
  Attributes:
29062 
   - success
29063 
  """
29064 
 
29065 
  thrift_spec = (
29066 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29067 
  )
29068 
 
29069 
  def __init__(self, success=None,):
29070 
    self.success = success
29071 
 
29072 
  def read(self, iprot):
29073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29075 
      return
29076 
    iprot.readStructBegin()
29077 
    while True:
29078 
      (fname, ftype, fid) = iprot.readFieldBegin()
29079 
      if ftype == TType.STOP:
29080 
        break
29081 
      if fid == 0:
29082 
        if ftype == TType.LIST:
29083 
          self.success = []
6188 rajveer 29084 
          (_etype696, _size693) = iprot.readListBegin()
29085 
          for _i697 in xrange(_size693):
29086 
            _elem698 = RechargePlan()
29087 
            _elem698.read(iprot)
29088 
            self.success.append(_elem698)
6159 rajveer 29089 
          iprot.readListEnd()
29090 
        else:
29091 
          iprot.skip(ftype)
29092 
      else:
29093 
        iprot.skip(ftype)
29094 
      iprot.readFieldEnd()
29095 
    iprot.readStructEnd()
29096 
 
29097 
  def write(self, oprot):
29098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29100 
      return
29101 
    oprot.writeStructBegin('getPlansForOperator_result')
29102 
    if self.success is not None:
29103 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29104 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29105 
      for iter699 in self.success:
29106 
        iter699.write(oprot)
6159 rajveer 29107 
      oprot.writeListEnd()
29108 
      oprot.writeFieldEnd()
29109 
    oprot.writeFieldStop()
29110 
    oprot.writeStructEnd()
29111 
 
29112 
  def validate(self):
29113 
    return
29114 
 
29115 
 
29116 
  def __repr__(self):
29117 
    L = ['%s=%r' % (key, value)
29118 
      for key, value in self.__dict__.iteritems()]
29119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29120 
 
29121 
  def __eq__(self, other):
29122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29123 
 
29124 
  def __ne__(self, other):
29125 
    return not (self == other)
6289 anupam.sin 29126 
 
29127 
class getRechargeDenominations_args:
29128 
  """
29129 
  Attributes:
29130 
   - operatorId
6307 anupam.sin 29131 
   - circleCode
6289 anupam.sin 29132 
   - denominationType
29133 
  """
29134 
 
29135 
  thrift_spec = (
29136 
    None, # 0
29137 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29138 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29139 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29140 
  )
29141 
 
6307 anupam.sin 29142 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29143 
    self.operatorId = operatorId
6307 anupam.sin 29144 
    self.circleCode = circleCode
6289 anupam.sin 29145 
    self.denominationType = denominationType
29146 
 
29147 
  def read(self, iprot):
29148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29150 
      return
29151 
    iprot.readStructBegin()
29152 
    while True:
29153 
      (fname, ftype, fid) = iprot.readFieldBegin()
29154 
      if ftype == TType.STOP:
29155 
        break
29156 
      if fid == 1:
29157 
        if ftype == TType.I64:
29158 
          self.operatorId = iprot.readI64();
29159 
        else:
29160 
          iprot.skip(ftype)
29161 
      elif fid == 2:
29162 
        if ftype == TType.STRING:
6307 anupam.sin 29163 
          self.circleCode = iprot.readString();
6289 anupam.sin 29164 
        else:
29165 
          iprot.skip(ftype)
29166 
      elif fid == 3:
29167 
        if ftype == TType.I32:
29168 
          self.denominationType = iprot.readI32();
29169 
        else:
29170 
          iprot.skip(ftype)
29171 
      else:
29172 
        iprot.skip(ftype)
29173 
      iprot.readFieldEnd()
29174 
    iprot.readStructEnd()
29175 
 
29176 
  def write(self, oprot):
29177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29179 
      return
29180 
    oprot.writeStructBegin('getRechargeDenominations_args')
29181 
    if self.operatorId is not None:
29182 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29183 
      oprot.writeI64(self.operatorId)
29184 
      oprot.writeFieldEnd()
6307 anupam.sin 29185 
    if self.circleCode is not None:
29186 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29187 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29188 
      oprot.writeFieldEnd()
29189 
    if self.denominationType is not None:
29190 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29191 
      oprot.writeI32(self.denominationType)
29192 
      oprot.writeFieldEnd()
29193 
    oprot.writeFieldStop()
29194 
    oprot.writeStructEnd()
29195 
 
29196 
  def validate(self):
29197 
    return
29198 
 
29199 
 
29200 
  def __repr__(self):
29201 
    L = ['%s=%r' % (key, value)
29202 
      for key, value in self.__dict__.iteritems()]
29203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29204 
 
29205 
  def __eq__(self, other):
29206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29207 
 
29208 
  def __ne__(self, other):
29209 
    return not (self == other)
29210 
 
29211 
class getRechargeDenominations_result:
29212 
  """
29213 
  Attributes:
29214 
   - success
29215 
   - ex
29216 
  """
29217 
 
29218 
  thrift_spec = (
29219 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29220 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29221 
  )
29222 
 
29223 
  def __init__(self, success=None, ex=None,):
29224 
    self.success = success
29225 
    self.ex = ex
29226 
 
29227 
  def read(self, iprot):
29228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29230 
      return
29231 
    iprot.readStructBegin()
29232 
    while True:
29233 
      (fname, ftype, fid) = iprot.readFieldBegin()
29234 
      if ftype == TType.STOP:
29235 
        break
29236 
      if fid == 0:
29237 
        if ftype == TType.LIST:
29238 
          self.success = []
29239 
          (_etype703, _size700) = iprot.readListBegin()
29240 
          for _i704 in xrange(_size700):
29241 
            _elem705 = RechargeDenomination()
29242 
            _elem705.read(iprot)
29243 
            self.success.append(_elem705)
29244 
          iprot.readListEnd()
29245 
        else:
29246 
          iprot.skip(ftype)
29247 
      elif fid == 1:
29248 
        if ftype == TType.STRUCT:
29249 
          self.ex = TransactionServiceException()
29250 
          self.ex.read(iprot)
29251 
        else:
29252 
          iprot.skip(ftype)
29253 
      else:
29254 
        iprot.skip(ftype)
29255 
      iprot.readFieldEnd()
29256 
    iprot.readStructEnd()
29257 
 
29258 
  def write(self, oprot):
29259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29261 
      return
29262 
    oprot.writeStructBegin('getRechargeDenominations_result')
29263 
    if self.success is not None:
29264 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29265 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29266 
      for iter706 in self.success:
29267 
        iter706.write(oprot)
29268 
      oprot.writeListEnd()
29269 
      oprot.writeFieldEnd()
29270 
    if self.ex is not None:
29271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29272 
      self.ex.write(oprot)
29273 
      oprot.writeFieldEnd()
29274 
    oprot.writeFieldStop()
29275 
    oprot.writeStructEnd()
29276 
 
29277 
  def validate(self):
29278 
    return
29279 
 
29280 
 
29281 
  def __repr__(self):
29282 
    L = ['%s=%r' % (key, value)
29283 
      for key, value in self.__dict__.iteritems()]
29284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29285 
 
29286 
  def __eq__(self, other):
29287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29288 
 
29289 
  def __ne__(self, other):
29290 
    return not (self == other)
6371 rajveer 29291 
 
29292 
class updateAvailabilityStatus_args:
29293 
  """
29294 
  Attributes:
29295 
   - operatorId
29296 
   - circleId
29297 
   - isAvailable
29298 
  """
29299 
 
29300 
  thrift_spec = (
29301 
    None, # 0
29302 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29303 
    (2, TType.I64, 'circleId', None, None, ), # 2
29304 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29305 
  )
29306 
 
29307 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29308 
    self.operatorId = operatorId
29309 
    self.circleId = circleId
29310 
    self.isAvailable = isAvailable
29311 
 
29312 
  def read(self, iprot):
29313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29315 
      return
29316 
    iprot.readStructBegin()
29317 
    while True:
29318 
      (fname, ftype, fid) = iprot.readFieldBegin()
29319 
      if ftype == TType.STOP:
29320 
        break
29321 
      if fid == 1:
29322 
        if ftype == TType.I64:
29323 
          self.operatorId = iprot.readI64();
29324 
        else:
29325 
          iprot.skip(ftype)
29326 
      elif fid == 2:
29327 
        if ftype == TType.I64:
29328 
          self.circleId = iprot.readI64();
29329 
        else:
29330 
          iprot.skip(ftype)
29331 
      elif fid == 3:
29332 
        if ftype == TType.BOOL:
29333 
          self.isAvailable = iprot.readBool();
29334 
        else:
29335 
          iprot.skip(ftype)
29336 
      else:
29337 
        iprot.skip(ftype)
29338 
      iprot.readFieldEnd()
29339 
    iprot.readStructEnd()
29340 
 
29341 
  def write(self, oprot):
29342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29344 
      return
29345 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29346 
    if self.operatorId is not None:
29347 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29348 
      oprot.writeI64(self.operatorId)
29349 
      oprot.writeFieldEnd()
29350 
    if self.circleId is not None:
29351 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29352 
      oprot.writeI64(self.circleId)
29353 
      oprot.writeFieldEnd()
29354 
    if self.isAvailable is not None:
29355 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29356 
      oprot.writeBool(self.isAvailable)
29357 
      oprot.writeFieldEnd()
29358 
    oprot.writeFieldStop()
29359 
    oprot.writeStructEnd()
29360 
 
29361 
  def validate(self):
29362 
    return
29363 
 
29364 
 
29365 
  def __repr__(self):
29366 
    L = ['%s=%r' % (key, value)
29367 
      for key, value in self.__dict__.iteritems()]
29368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29369 
 
29370 
  def __eq__(self, other):
29371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29372 
 
29373 
  def __ne__(self, other):
29374 
    return not (self == other)
29375 
 
29376 
class updateAvailabilityStatus_result:
29377 
 
29378 
  thrift_spec = (
29379 
  )
29380 
 
29381 
  def read(self, iprot):
29382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29384 
      return
29385 
    iprot.readStructBegin()
29386 
    while True:
29387 
      (fname, ftype, fid) = iprot.readFieldBegin()
29388 
      if ftype == TType.STOP:
29389 
        break
29390 
      else:
29391 
        iprot.skip(ftype)
29392 
      iprot.readFieldEnd()
29393 
    iprot.readStructEnd()
29394 
 
29395 
  def write(self, oprot):
29396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29398 
      return
29399 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29400 
    oprot.writeFieldStop()
29401 
    oprot.writeStructEnd()
29402 
 
29403 
  def validate(self):
29404 
    return
29405 
 
29406 
 
29407 
  def __repr__(self):
29408 
    L = ['%s=%r' % (key, value)
29409 
      for key, value in self.__dict__.iteritems()]
29410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29411 
 
29412 
  def __eq__(self, other):
29413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29414 
 
29415 
  def __ne__(self, other):
29416 
    return not (self == other)
6389 rajveer 29417 
 
29418 
class getAvailableEmiSchemes_args:
29419 
 
29420 
  thrift_spec = (
29421 
  )
29422 
 
29423 
  def read(self, iprot):
29424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29426 
      return
29427 
    iprot.readStructBegin()
29428 
    while True:
29429 
      (fname, ftype, fid) = iprot.readFieldBegin()
29430 
      if ftype == TType.STOP:
29431 
        break
29432 
      else:
29433 
        iprot.skip(ftype)
29434 
      iprot.readFieldEnd()
29435 
    iprot.readStructEnd()
29436 
 
29437 
  def write(self, oprot):
29438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29440 
      return
29441 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29442 
    oprot.writeFieldStop()
29443 
    oprot.writeStructEnd()
29444 
 
29445 
  def validate(self):
29446 
    return
29447 
 
29448 
 
29449 
  def __repr__(self):
29450 
    L = ['%s=%r' % (key, value)
29451 
      for key, value in self.__dict__.iteritems()]
29452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29453 
 
29454 
  def __eq__(self, other):
29455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29456 
 
29457 
  def __ne__(self, other):
29458 
    return not (self == other)
29459 
 
29460 
class getAvailableEmiSchemes_result:
29461 
  """
29462 
  Attributes:
29463 
   - success
29464 
  """
29465 
 
29466 
  thrift_spec = (
29467 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29468 
  )
29469 
 
29470 
  def __init__(self, success=None,):
29471 
    self.success = success
29472 
 
29473 
  def read(self, iprot):
29474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29476 
      return
29477 
    iprot.readStructBegin()
29478 
    while True:
29479 
      (fname, ftype, fid) = iprot.readFieldBegin()
29480 
      if ftype == TType.STOP:
29481 
        break
29482 
      if fid == 0:
29483 
        if ftype == TType.LIST:
29484 
          self.success = []
29485 
          (_etype710, _size707) = iprot.readListBegin()
29486 
          for _i711 in xrange(_size707):
29487 
            _elem712 = EmiScheme()
29488 
            _elem712.read(iprot)
29489 
            self.success.append(_elem712)
29490 
          iprot.readListEnd()
29491 
        else:
29492 
          iprot.skip(ftype)
29493 
      else:
29494 
        iprot.skip(ftype)
29495 
      iprot.readFieldEnd()
29496 
    iprot.readStructEnd()
29497 
 
29498 
  def write(self, oprot):
29499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29501 
      return
29502 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29503 
    if self.success is not None:
29504 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29505 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29506 
      for iter713 in self.success:
29507 
        iter713.write(oprot)
29508 
      oprot.writeListEnd()
29509 
      oprot.writeFieldEnd()
29510 
    oprot.writeFieldStop()
29511 
    oprot.writeStructEnd()
29512 
 
29513 
  def validate(self):
29514 
    return
29515 
 
29516 
 
29517 
  def __repr__(self):
29518 
    L = ['%s=%r' % (key, value)
29519 
      for key, value in self.__dict__.iteritems()]
29520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29521 
 
29522 
  def __eq__(self, other):
29523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29524 
 
29525 
  def __ne__(self, other):
29526 
    return not (self == other)
29527 
 
29528 
class getMiscCharges_args:
29529 
  """
29530 
  Attributes:
29531 
   - transactionId
29532 
  """
29533 
 
29534 
  thrift_spec = (
29535 
    None, # 0
29536 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29537 
  )
29538 
 
29539 
  def __init__(self, transactionId=None,):
29540 
    self.transactionId = transactionId
29541 
 
29542 
  def read(self, iprot):
29543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29545 
      return
29546 
    iprot.readStructBegin()
29547 
    while True:
29548 
      (fname, ftype, fid) = iprot.readFieldBegin()
29549 
      if ftype == TType.STOP:
29550 
        break
29551 
      if fid == 1:
29552 
        if ftype == TType.I64:
29553 
          self.transactionId = iprot.readI64();
29554 
        else:
29555 
          iprot.skip(ftype)
29556 
      else:
29557 
        iprot.skip(ftype)
29558 
      iprot.readFieldEnd()
29559 
    iprot.readStructEnd()
29560 
 
29561 
  def write(self, oprot):
29562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29564 
      return
29565 
    oprot.writeStructBegin('getMiscCharges_args')
29566 
    if self.transactionId is not None:
29567 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29568 
      oprot.writeI64(self.transactionId)
29569 
      oprot.writeFieldEnd()
29570 
    oprot.writeFieldStop()
29571 
    oprot.writeStructEnd()
29572 
 
29573 
  def validate(self):
29574 
    return
29575 
 
29576 
 
29577 
  def __repr__(self):
29578 
    L = ['%s=%r' % (key, value)
29579 
      for key, value in self.__dict__.iteritems()]
29580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29581 
 
29582 
  def __eq__(self, other):
29583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29584 
 
29585 
  def __ne__(self, other):
29586 
    return not (self == other)
29587 
 
29588 
class getMiscCharges_result:
29589 
  """
29590 
  Attributes:
29591 
   - success
29592 
  """
29593 
 
29594 
  thrift_spec = (
6412 rajveer 29595 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29596 
  )
29597 
 
29598 
  def __init__(self, success=None,):
29599 
    self.success = success
29600 
 
29601 
  def read(self, iprot):
29602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29604 
      return
29605 
    iprot.readStructBegin()
29606 
    while True:
29607 
      (fname, ftype, fid) = iprot.readFieldBegin()
29608 
      if ftype == TType.STOP:
29609 
        break
29610 
      if fid == 0:
29611 
        if ftype == TType.MAP:
29612 
          self.success = {}
29613 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29614 
          for _i718 in xrange(_size714):
29615 
            _key719 = iprot.readI64();
6412 rajveer 29616 
            _val720 = iprot.readDouble();
6389 rajveer 29617 
            self.success[_key719] = _val720
29618 
          iprot.readMapEnd()
29619 
        else:
29620 
          iprot.skip(ftype)
29621 
      else:
29622 
        iprot.skip(ftype)
29623 
      iprot.readFieldEnd()
29624 
    iprot.readStructEnd()
29625 
 
29626 
  def write(self, oprot):
29627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29629 
      return
29630 
    oprot.writeStructBegin('getMiscCharges_result')
29631 
    if self.success is not None:
29632 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29633 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29634 
      for kiter721,viter722 in self.success.items():
29635 
        oprot.writeI64(kiter721)
6412 rajveer 29636 
        oprot.writeDouble(viter722)
6389 rajveer 29637 
      oprot.writeMapEnd()
29638 
      oprot.writeFieldEnd()
29639 
    oprot.writeFieldStop()
29640 
    oprot.writeStructEnd()
29641 
 
29642 
  def validate(self):
29643 
    return
29644 
 
29645 
 
29646 
  def __repr__(self):
29647 
    L = ['%s=%r' % (key, value)
29648 
      for key, value in self.__dict__.iteritems()]
29649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29650 
 
29651 
  def __eq__(self, other):
29652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29653 
 
29654 
  def __ne__(self, other):
29655 
    return not (self == other)
6507 anupam.sin 29656 
 
29657 
class refundRechargeOrder_args:
29658 
  """
29659 
  Attributes:
29660 
   - rechargeOrderId
29661 
  """
29662 
 
29663 
  thrift_spec = (
29664 
    None, # 0
29665 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29666 
  )
29667 
 
29668 
  def __init__(self, rechargeOrderId=None,):
29669 
    self.rechargeOrderId = rechargeOrderId
29670 
 
29671 
  def read(self, iprot):
29672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29674 
      return
29675 
    iprot.readStructBegin()
29676 
    while True:
29677 
      (fname, ftype, fid) = iprot.readFieldBegin()
29678 
      if ftype == TType.STOP:
29679 
        break
29680 
      if fid == 1:
29681 
        if ftype == TType.I64:
29682 
          self.rechargeOrderId = iprot.readI64();
29683 
        else:
29684 
          iprot.skip(ftype)
29685 
      else:
29686 
        iprot.skip(ftype)
29687 
      iprot.readFieldEnd()
29688 
    iprot.readStructEnd()
29689 
 
29690 
  def write(self, oprot):
29691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29693 
      return
29694 
    oprot.writeStructBegin('refundRechargeOrder_args')
29695 
    if self.rechargeOrderId is not None:
29696 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29697 
      oprot.writeI64(self.rechargeOrderId)
29698 
      oprot.writeFieldEnd()
29699 
    oprot.writeFieldStop()
29700 
    oprot.writeStructEnd()
29701 
 
29702 
  def validate(self):
29703 
    return
29704 
 
29705 
 
29706 
  def __repr__(self):
29707 
    L = ['%s=%r' % (key, value)
29708 
      for key, value in self.__dict__.iteritems()]
29709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29710 
 
29711 
  def __eq__(self, other):
29712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29713 
 
29714 
  def __ne__(self, other):
29715 
    return not (self == other)
29716 
 
29717 
class refundRechargeOrder_result:
29718 
  """
29719 
  Attributes:
29720 
   - success
29721 
   - ex
29722 
  """
29723 
 
29724 
  thrift_spec = (
29725 
    (0, TType.BOOL, 'success', None, None, ), # 0
29726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29727 
  )
29728 
 
29729 
  def __init__(self, success=None, ex=None,):
29730 
    self.success = success
29731 
    self.ex = ex
29732 
 
29733 
  def read(self, iprot):
29734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29736 
      return
29737 
    iprot.readStructBegin()
29738 
    while True:
29739 
      (fname, ftype, fid) = iprot.readFieldBegin()
29740 
      if ftype == TType.STOP:
29741 
        break
29742 
      if fid == 0:
29743 
        if ftype == TType.BOOL:
29744 
          self.success = iprot.readBool();
29745 
        else:
29746 
          iprot.skip(ftype)
29747 
      elif fid == 1:
29748 
        if ftype == TType.STRUCT:
29749 
          self.ex = TransactionServiceException()
29750 
          self.ex.read(iprot)
29751 
        else:
29752 
          iprot.skip(ftype)
29753 
      else:
29754 
        iprot.skip(ftype)
29755 
      iprot.readFieldEnd()
29756 
    iprot.readStructEnd()
29757 
 
29758 
  def write(self, oprot):
29759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29761 
      return
29762 
    oprot.writeStructBegin('refundRechargeOrder_result')
29763 
    if self.success is not None:
29764 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29765 
      oprot.writeBool(self.success)
29766 
      oprot.writeFieldEnd()
29767 
    if self.ex is not None:
29768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29769 
      self.ex.write(oprot)
29770 
      oprot.writeFieldEnd()
29771 
    oprot.writeFieldStop()
29772 
    oprot.writeStructEnd()
29773 
 
29774 
  def validate(self):
29775 
    return
29776 
 
29777 
 
29778 
  def __repr__(self):
29779 
    L = ['%s=%r' % (key, value)
29780 
      for key, value in self.__dict__.iteritems()]
29781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29782 
 
29783 
  def __eq__(self, other):
29784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29785 
 
29786 
  def __ne__(self, other):
29787 
    return not (self == other)
6821 amar.kumar 29788 
 
29789 
class getPhysicalOrders_args:
29790 
  """
29791 
  Attributes:
29792 
   - fromDate
29793 
   - toDate
29794 
  """
29795 
 
29796 
  thrift_spec = (
29797 
    None, # 0
29798 
    (1, TType.I64, 'fromDate', None, None, ), # 1
29799 
    (2, TType.I64, 'toDate', None, None, ), # 2
29800 
  )
29801 
 
29802 
  def __init__(self, fromDate=None, toDate=None,):
29803 
    self.fromDate = fromDate
29804 
    self.toDate = toDate
29805 
 
29806 
  def read(self, iprot):
29807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29809 
      return
29810 
    iprot.readStructBegin()
29811 
    while True:
29812 
      (fname, ftype, fid) = iprot.readFieldBegin()
29813 
      if ftype == TType.STOP:
29814 
        break
29815 
      if fid == 1:
29816 
        if ftype == TType.I64:
29817 
          self.fromDate = iprot.readI64();
29818 
        else:
29819 
          iprot.skip(ftype)
29820 
      elif fid == 2:
29821 
        if ftype == TType.I64:
29822 
          self.toDate = iprot.readI64();
29823 
        else:
29824 
          iprot.skip(ftype)
29825 
      else:
29826 
        iprot.skip(ftype)
29827 
      iprot.readFieldEnd()
29828 
    iprot.readStructEnd()
29829 
 
29830 
  def write(self, oprot):
29831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29833 
      return
29834 
    oprot.writeStructBegin('getPhysicalOrders_args')
29835 
    if self.fromDate is not None:
29836 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
29837 
      oprot.writeI64(self.fromDate)
29838 
      oprot.writeFieldEnd()
29839 
    if self.toDate is not None:
29840 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
29841 
      oprot.writeI64(self.toDate)
29842 
      oprot.writeFieldEnd()
29843 
    oprot.writeFieldStop()
29844 
    oprot.writeStructEnd()
29845 
 
29846 
  def validate(self):
29847 
    return
29848 
 
29849 
 
29850 
  def __repr__(self):
29851 
    L = ['%s=%r' % (key, value)
29852 
      for key, value in self.__dict__.iteritems()]
29853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29854 
 
29855 
  def __eq__(self, other):
29856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29857 
 
29858 
  def __ne__(self, other):
29859 
    return not (self == other)
29860 
 
29861 
class getPhysicalOrders_result:
29862 
  """
29863 
  Attributes:
29864 
   - success
29865 
  """
29866 
 
29867 
  thrift_spec = (
29868 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
29869 
  )
29870 
 
29871 
  def __init__(self, success=None,):
29872 
    self.success = success
29873 
 
29874 
  def read(self, iprot):
29875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29877 
      return
29878 
    iprot.readStructBegin()
29879 
    while True:
29880 
      (fname, ftype, fid) = iprot.readFieldBegin()
29881 
      if ftype == TType.STOP:
29882 
        break
29883 
      if fid == 0:
29884 
        if ftype == TType.LIST:
29885 
          self.success = []
29886 
          (_etype726, _size723) = iprot.readListBegin()
29887 
          for _i727 in xrange(_size723):
29888 
            _elem728 = Order()
29889 
            _elem728.read(iprot)
29890 
            self.success.append(_elem728)
29891 
          iprot.readListEnd()
29892 
        else:
29893 
          iprot.skip(ftype)
29894 
      else:
29895 
        iprot.skip(ftype)
29896 
      iprot.readFieldEnd()
29897 
    iprot.readStructEnd()
29898 
 
29899 
  def write(self, oprot):
29900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29902 
      return
29903 
    oprot.writeStructBegin('getPhysicalOrders_result')
29904 
    if self.success is not None:
29905 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29906 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29907 
      for iter729 in self.success:
29908 
        iter729.write(oprot)
29909 
      oprot.writeListEnd()
29910 
      oprot.writeFieldEnd()
29911 
    oprot.writeFieldStop()
29912 
    oprot.writeStructEnd()
29913 
 
29914 
  def validate(self):
29915 
    return
29916 
 
29917 
 
29918 
  def __repr__(self):
29919 
    L = ['%s=%r' % (key, value)
29920 
      for key, value in self.__dict__.iteritems()]
29921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29922 
 
29923 
  def __eq__(self, other):
29924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29925 
 
29926 
  def __ne__(self, other):
29927 
    return not (self == other)
6906 rajveer 29928 
 
29929 
class getDocument_args:
29930 
  """
29931 
  Attributes:
29932 
   - docType
29933 
   - docSource
29934 
  """
29935 
 
29936 
  thrift_spec = (
29937 
    None, # 0
29938 
    (1, TType.I64, 'docType', None, None, ), # 1
29939 
    (2, TType.I64, 'docSource', None, None, ), # 2
29940 
  )
29941 
 
29942 
  def __init__(self, docType=None, docSource=None,):
29943 
    self.docType = docType
29944 
    self.docSource = docSource
29945 
 
29946 
  def read(self, iprot):
29947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29949 
      return
29950 
    iprot.readStructBegin()
29951 
    while True:
29952 
      (fname, ftype, fid) = iprot.readFieldBegin()
29953 
      if ftype == TType.STOP:
29954 
        break
29955 
      if fid == 1:
29956 
        if ftype == TType.I64:
29957 
          self.docType = iprot.readI64();
29958 
        else:
29959 
          iprot.skip(ftype)
29960 
      elif fid == 2:
29961 
        if ftype == TType.I64:
29962 
          self.docSource = iprot.readI64();
29963 
        else:
29964 
          iprot.skip(ftype)
29965 
      else:
29966 
        iprot.skip(ftype)
29967 
      iprot.readFieldEnd()
29968 
    iprot.readStructEnd()
29969 
 
29970 
  def write(self, oprot):
29971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29973 
      return
29974 
    oprot.writeStructBegin('getDocument_args')
29975 
    if self.docType is not None:
29976 
      oprot.writeFieldBegin('docType', TType.I64, 1)
29977 
      oprot.writeI64(self.docType)
29978 
      oprot.writeFieldEnd()
29979 
    if self.docSource is not None:
29980 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
29981 
      oprot.writeI64(self.docSource)
29982 
      oprot.writeFieldEnd()
29983 
    oprot.writeFieldStop()
29984 
    oprot.writeStructEnd()
29985 
 
29986 
  def validate(self):
29987 
    return
29988 
 
29989 
 
29990 
  def __repr__(self):
29991 
    L = ['%s=%r' % (key, value)
29992 
      for key, value in self.__dict__.iteritems()]
29993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29994 
 
29995 
  def __eq__(self, other):
29996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29997 
 
29998 
  def __ne__(self, other):
29999 
    return not (self == other)
30000 
 
30001 
class getDocument_result:
30002 
  """
30003 
  Attributes:
30004 
   - success
30005 
  """
30006 
 
30007 
  thrift_spec = (
30008 
    (0, TType.STRING, 'success', None, None, ), # 0
30009 
  )
30010 
 
30011 
  def __init__(self, success=None,):
30012 
    self.success = success
30013 
 
30014 
  def read(self, iprot):
30015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30017 
      return
30018 
    iprot.readStructBegin()
30019 
    while True:
30020 
      (fname, ftype, fid) = iprot.readFieldBegin()
30021 
      if ftype == TType.STOP:
30022 
        break
30023 
      if fid == 0:
30024 
        if ftype == TType.STRING:
30025 
          self.success = iprot.readString();
30026 
        else:
30027 
          iprot.skip(ftype)
30028 
      else:
30029 
        iprot.skip(ftype)
30030 
      iprot.readFieldEnd()
30031 
    iprot.readStructEnd()
30032 
 
30033 
  def write(self, oprot):
30034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30036 
      return
30037 
    oprot.writeStructBegin('getDocument_result')
30038 
    if self.success is not None:
30039 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30040 
      oprot.writeString(self.success)
30041 
      oprot.writeFieldEnd()
30042 
    oprot.writeFieldStop()
30043 
    oprot.writeStructEnd()
30044 
 
30045 
  def validate(self):
30046 
    return
30047 
 
30048 
 
30049 
  def __repr__(self):
30050 
    L = ['%s=%r' % (key, value)
30051 
      for key, value in self.__dict__.iteritems()]
30052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30053 
 
30054 
  def __eq__(self, other):
30055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30056 
 
30057 
  def __ne__(self, other):
30058 
    return not (self == other)
6985 anupam.sin 30059 
 
30060 
class changeShippingAddress_args:
30061 
  """
30062 
  Attributes:
30063 
   - orderId
30064 
   - line1
30065 
   - line2
30066 
   - city
30067 
   - state
30068 
   - pin
30069 
  """
30070 
 
30071 
  thrift_spec = (
30072 
    None, # 0
30073 
    (1, TType.I64, 'orderId', None, None, ), # 1
30074 
    (2, TType.STRING, 'line1', None, None, ), # 2
30075 
    (3, TType.STRING, 'line2', None, None, ), # 3
30076 
    (4, TType.STRING, 'city', None, None, ), # 4
30077 
    (5, TType.STRING, 'state', None, None, ), # 5
30078 
    (6, TType.STRING, 'pin', None, None, ), # 6
30079 
  )
30080 
 
30081 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30082 
    self.orderId = orderId
30083 
    self.line1 = line1
30084 
    self.line2 = line2
30085 
    self.city = city
30086 
    self.state = state
30087 
    self.pin = pin
30088 
 
30089 
  def read(self, iprot):
30090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30092 
      return
30093 
    iprot.readStructBegin()
30094 
    while True:
30095 
      (fname, ftype, fid) = iprot.readFieldBegin()
30096 
      if ftype == TType.STOP:
30097 
        break
30098 
      if fid == 1:
30099 
        if ftype == TType.I64:
30100 
          self.orderId = iprot.readI64();
30101 
        else:
30102 
          iprot.skip(ftype)
30103 
      elif fid == 2:
30104 
        if ftype == TType.STRING:
30105 
          self.line1 = iprot.readString();
30106 
        else:
30107 
          iprot.skip(ftype)
30108 
      elif fid == 3:
30109 
        if ftype == TType.STRING:
30110 
          self.line2 = iprot.readString();
30111 
        else:
30112 
          iprot.skip(ftype)
30113 
      elif fid == 4:
30114 
        if ftype == TType.STRING:
30115 
          self.city = iprot.readString();
30116 
        else:
30117 
          iprot.skip(ftype)
30118 
      elif fid == 5:
30119 
        if ftype == TType.STRING:
30120 
          self.state = iprot.readString();
30121 
        else:
30122 
          iprot.skip(ftype)
30123 
      elif fid == 6:
30124 
        if ftype == TType.STRING:
30125 
          self.pin = iprot.readString();
30126 
        else:
30127 
          iprot.skip(ftype)
30128 
      else:
30129 
        iprot.skip(ftype)
30130 
      iprot.readFieldEnd()
30131 
    iprot.readStructEnd()
30132 
 
30133 
  def write(self, oprot):
30134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30136 
      return
30137 
    oprot.writeStructBegin('changeShippingAddress_args')
30138 
    if self.orderId is not None:
30139 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30140 
      oprot.writeI64(self.orderId)
30141 
      oprot.writeFieldEnd()
30142 
    if self.line1 is not None:
30143 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30144 
      oprot.writeString(self.line1)
30145 
      oprot.writeFieldEnd()
30146 
    if self.line2 is not None:
30147 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30148 
      oprot.writeString(self.line2)
30149 
      oprot.writeFieldEnd()
30150 
    if self.city is not None:
30151 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30152 
      oprot.writeString(self.city)
30153 
      oprot.writeFieldEnd()
30154 
    if self.state is not None:
30155 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30156 
      oprot.writeString(self.state)
30157 
      oprot.writeFieldEnd()
30158 
    if self.pin is not None:
30159 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30160 
      oprot.writeString(self.pin)
30161 
      oprot.writeFieldEnd()
30162 
    oprot.writeFieldStop()
30163 
    oprot.writeStructEnd()
30164 
 
30165 
  def validate(self):
30166 
    return
30167 
 
30168 
 
30169 
  def __repr__(self):
30170 
    L = ['%s=%r' % (key, value)
30171 
      for key, value in self.__dict__.iteritems()]
30172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30173 
 
30174 
  def __eq__(self, other):
30175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30176 
 
30177 
  def __ne__(self, other):
30178 
    return not (self == other)
30179 
 
30180 
class changeShippingAddress_result:
30181 
  """
30182 
  Attributes:
30183 
   - success
30184 
  """
30185 
 
30186 
  thrift_spec = (
30187 
    (0, TType.BOOL, 'success', None, None, ), # 0
30188 
  )
30189 
 
30190 
  def __init__(self, success=None,):
30191 
    self.success = success
30192 
 
30193 
  def read(self, iprot):
30194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30196 
      return
30197 
    iprot.readStructBegin()
30198 
    while True:
30199 
      (fname, ftype, fid) = iprot.readFieldBegin()
30200 
      if ftype == TType.STOP:
30201 
        break
30202 
      if fid == 0:
30203 
        if ftype == TType.BOOL:
30204 
          self.success = iprot.readBool();
30205 
        else:
30206 
          iprot.skip(ftype)
30207 
      else:
30208 
        iprot.skip(ftype)
30209 
      iprot.readFieldEnd()
30210 
    iprot.readStructEnd()
30211 
 
30212 
  def write(self, oprot):
30213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30215 
      return
30216 
    oprot.writeStructBegin('changeShippingAddress_result')
30217 
    if self.success is not None:
30218 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30219 
      oprot.writeBool(self.success)
30220 
      oprot.writeFieldEnd()
30221 
    oprot.writeFieldStop()
30222 
    oprot.writeStructEnd()
30223 
 
30224 
  def validate(self):
30225 
    return
30226 
 
30227 
 
30228 
  def __repr__(self):
30229 
    L = ['%s=%r' % (key, value)
30230 
      for key, value in self.__dict__.iteritems()]
30231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30232 
 
30233 
  def __eq__(self, other):
30234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30235 
 
30236 
  def __ne__(self, other):
30237 
    return not (self == other)
6988 rajveer 30238 
 
30239 
class retrieveInvoice_args:
30240 
  """
30241 
  Attributes:
30242 
   - orderId
30243 
  """
30244 
 
30245 
  thrift_spec = (
30246 
    None, # 0
30247 
    (1, TType.I64, 'orderId', None, None, ), # 1
30248 
  )
30249 
 
30250 
  def __init__(self, orderId=None,):
30251 
    self.orderId = orderId
30252 
 
30253 
  def read(self, iprot):
30254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30256 
      return
30257 
    iprot.readStructBegin()
30258 
    while True:
30259 
      (fname, ftype, fid) = iprot.readFieldBegin()
30260 
      if ftype == TType.STOP:
30261 
        break
30262 
      if fid == 1:
30263 
        if ftype == TType.I64:
30264 
          self.orderId = iprot.readI64();
30265 
        else:
30266 
          iprot.skip(ftype)
30267 
      else:
30268 
        iprot.skip(ftype)
30269 
      iprot.readFieldEnd()
30270 
    iprot.readStructEnd()
30271 
 
30272 
  def write(self, oprot):
30273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30275 
      return
30276 
    oprot.writeStructBegin('retrieveInvoice_args')
30277 
    if self.orderId is not None:
30278 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30279 
      oprot.writeI64(self.orderId)
30280 
      oprot.writeFieldEnd()
30281 
    oprot.writeFieldStop()
30282 
    oprot.writeStructEnd()
30283 
 
30284 
  def validate(self):
30285 
    return
30286 
 
30287 
 
30288 
  def __repr__(self):
30289 
    L = ['%s=%r' % (key, value)
30290 
      for key, value in self.__dict__.iteritems()]
30291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30292 
 
30293 
  def __eq__(self, other):
30294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30295 
 
30296 
  def __ne__(self, other):
30297 
    return not (self == other)
30298 
 
30299 
class retrieveInvoice_result:
30300 
  """
30301 
  Attributes:
30302 
   - success
30303 
  """
30304 
 
30305 
  thrift_spec = (
30306 
    (0, TType.STRING, 'success', None, None, ), # 0
30307 
  )
30308 
 
30309 
  def __init__(self, success=None,):
30310 
    self.success = success
30311 
 
30312 
  def read(self, iprot):
30313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30315 
      return
30316 
    iprot.readStructBegin()
30317 
    while True:
30318 
      (fname, ftype, fid) = iprot.readFieldBegin()
30319 
      if ftype == TType.STOP:
30320 
        break
30321 
      if fid == 0:
30322 
        if ftype == TType.STRING:
30323 
          self.success = iprot.readString();
30324 
        else:
30325 
          iprot.skip(ftype)
30326 
      else:
30327 
        iprot.skip(ftype)
30328 
      iprot.readFieldEnd()
30329 
    iprot.readStructEnd()
30330 
 
30331 
  def write(self, oprot):
30332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30334 
      return
30335 
    oprot.writeStructBegin('retrieveInvoice_result')
30336 
    if self.success is not None:
30337 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30338 
      oprot.writeString(self.success)
30339 
      oprot.writeFieldEnd()
30340 
    oprot.writeFieldStop()
30341 
    oprot.writeStructEnd()
30342 
 
30343 
  def validate(self):
30344 
    return
30345 
 
30346 
 
30347 
  def __repr__(self):
30348 
    L = ['%s=%r' % (key, value)
30349 
      for key, value in self.__dict__.iteritems()]
30350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30351 
 
30352 
  def __eq__(self, other):
30353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30354 
 
30355 
  def __ne__(self, other):
30356 
    return not (self == other)
7026 rajveer 30357 
 
30358 
class receiveUpdatesForRedExpress_args:
30359 
  """
30360 
  Attributes:
30361 
   - awbNumber
30362 
  """
30363 
 
30364 
  thrift_spec = (
30365 
    None, # 0
30366 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30367 
  )
30368 
 
30369 
  def __init__(self, awbNumber=None,):
30370 
    self.awbNumber = awbNumber
30371 
 
30372 
  def read(self, iprot):
30373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30375 
      return
30376 
    iprot.readStructBegin()
30377 
    while True:
30378 
      (fname, ftype, fid) = iprot.readFieldBegin()
30379 
      if ftype == TType.STOP:
30380 
        break
30381 
      if fid == 1:
30382 
        if ftype == TType.STRING:
30383 
          self.awbNumber = iprot.readString();
30384 
        else:
30385 
          iprot.skip(ftype)
30386 
      else:
30387 
        iprot.skip(ftype)
30388 
      iprot.readFieldEnd()
30389 
    iprot.readStructEnd()
30390 
 
30391 
  def write(self, oprot):
30392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30394 
      return
30395 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30396 
    if self.awbNumber is not None:
30397 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30398 
      oprot.writeString(self.awbNumber)
30399 
      oprot.writeFieldEnd()
30400 
    oprot.writeFieldStop()
30401 
    oprot.writeStructEnd()
30402 
 
30403 
  def validate(self):
30404 
    return
30405 
 
30406 
 
30407 
  def __repr__(self):
30408 
    L = ['%s=%r' % (key, value)
30409 
      for key, value in self.__dict__.iteritems()]
30410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30411 
 
30412 
  def __eq__(self, other):
30413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30414 
 
30415 
  def __ne__(self, other):
30416 
    return not (self == other)
30417 
 
30418 
class receiveUpdatesForRedExpress_result:
30419 
  """
30420 
  Attributes:
30421 
   - success
30422 
  """
30423 
 
30424 
  thrift_spec = (
30425 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30426 
  )
30427 
 
30428 
  def __init__(self, success=None,):
30429 
    self.success = success
30430 
 
30431 
  def read(self, iprot):
30432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30434 
      return
30435 
    iprot.readStructBegin()
30436 
    while True:
30437 
      (fname, ftype, fid) = iprot.readFieldBegin()
30438 
      if ftype == TType.STOP:
30439 
        break
30440 
      if fid == 0:
30441 
        if ftype == TType.LIST:
30442 
          self.success = []
30443 
          (_etype733, _size730) = iprot.readListBegin()
30444 
          for _i734 in xrange(_size730):
30445 
            _elem735 = iprot.readString();
30446 
            self.success.append(_elem735)
30447 
          iprot.readListEnd()
30448 
        else:
30449 
          iprot.skip(ftype)
30450 
      else:
30451 
        iprot.skip(ftype)
30452 
      iprot.readFieldEnd()
30453 
    iprot.readStructEnd()
30454 
 
30455 
  def write(self, oprot):
30456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30458 
      return
30459 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
30460 
    if self.success is not None:
30461 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30462 
      oprot.writeListBegin(TType.STRING, len(self.success))
30463 
      for iter736 in self.success:
30464 
        oprot.writeString(iter736)
30465 
      oprot.writeListEnd()
30466 
      oprot.writeFieldEnd()
30467 
    oprot.writeFieldStop()
30468 
    oprot.writeStructEnd()
30469 
 
30470 
  def validate(self):
30471 
    return
30472 
 
30473 
 
30474 
  def __repr__(self):
30475 
    L = ['%s=%r' % (key, value)
30476 
      for key, value in self.__dict__.iteritems()]
30477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30478 
 
30479 
  def __eq__(self, other):
30480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30481 
 
30482 
  def __ne__(self, other):
30483 
    return not (self == other)
7073 anupam.sin 30484 
 
30485 
class createRechargeTransaction_args:
30486 
  """
30487 
  Attributes:
30488 
   - thriftRechargeTransaction
30489 
  """
30490 
 
30491 
  thrift_spec = (
30492 
    None, # 0
30493 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
30494 
  )
30495 
 
30496 
  def __init__(self, thriftRechargeTransaction=None,):
30497 
    self.thriftRechargeTransaction = thriftRechargeTransaction
30498 
 
30499 
  def read(self, iprot):
30500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30502 
      return
30503 
    iprot.readStructBegin()
30504 
    while True:
30505 
      (fname, ftype, fid) = iprot.readFieldBegin()
30506 
      if ftype == TType.STOP:
30507 
        break
30508 
      if fid == 1:
30509 
        if ftype == TType.STRUCT:
30510 
          self.thriftRechargeTransaction = RechargeTransaction()
30511 
          self.thriftRechargeTransaction.read(iprot)
30512 
        else:
30513 
          iprot.skip(ftype)
30514 
      else:
30515 
        iprot.skip(ftype)
30516 
      iprot.readFieldEnd()
30517 
    iprot.readStructEnd()
30518 
 
30519 
  def write(self, oprot):
30520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30522 
      return
30523 
    oprot.writeStructBegin('createRechargeTransaction_args')
30524 
    if self.thriftRechargeTransaction is not None:
30525 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
30526 
      self.thriftRechargeTransaction.write(oprot)
30527 
      oprot.writeFieldEnd()
30528 
    oprot.writeFieldStop()
30529 
    oprot.writeStructEnd()
30530 
 
30531 
  def validate(self):
30532 
    return
30533 
 
30534 
 
30535 
  def __repr__(self):
30536 
    L = ['%s=%r' % (key, value)
30537 
      for key, value in self.__dict__.iteritems()]
30538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30539 
 
30540 
  def __eq__(self, other):
30541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30542 
 
30543 
  def __ne__(self, other):
30544 
    return not (self == other)
30545 
 
30546 
class createRechargeTransaction_result:
30547 
  """
30548 
  Attributes:
30549 
   - success
30550 
  """
30551 
 
30552 
  thrift_spec = (
30553 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
30554 
  )
30555 
 
30556 
  def __init__(self, success=None,):
30557 
    self.success = success
30558 
 
30559 
  def read(self, iprot):
30560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30562 
      return
30563 
    iprot.readStructBegin()
30564 
    while True:
30565 
      (fname, ftype, fid) = iprot.readFieldBegin()
30566 
      if ftype == TType.STOP:
30567 
        break
30568 
      if fid == 0:
30569 
        if ftype == TType.STRUCT:
30570 
          self.success = RechargeTransaction()
30571 
          self.success.read(iprot)
30572 
        else:
30573 
          iprot.skip(ftype)
30574 
      else:
30575 
        iprot.skip(ftype)
30576 
      iprot.readFieldEnd()
30577 
    iprot.readStructEnd()
30578 
 
30579 
  def write(self, oprot):
30580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30582 
      return
30583 
    oprot.writeStructBegin('createRechargeTransaction_result')
30584 
    if self.success is not None:
30585 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30586 
      self.success.write(oprot)
30587 
      oprot.writeFieldEnd()
30588 
    oprot.writeFieldStop()
30589 
    oprot.writeStructEnd()
30590 
 
30591 
  def validate(self):
30592 
    return
30593 
 
30594 
 
30595 
  def __repr__(self):
30596 
    L = ['%s=%r' % (key, value)
30597 
      for key, value in self.__dict__.iteritems()]
30598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30599 
 
30600 
  def __eq__(self, other):
30601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30602 
 
30603 
  def __ne__(self, other):
30604 
    return not (self == other)