Subversion Repositories SmartDukaan

Rev

Rev 7311 | Rev 7343 | 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 
 
7293 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
7293 anupam.sin 66 
     - source
94 ashish 67 
    """
68 
    pass
69 
 
1398 varun.gupt 70 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 71 
    """
72 
    Parameters:
73 
     - transactionId
74 
    """
75 
    pass
76 
 
4801 anupam.sin 77 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 78 
    """
79 
    Parameters:
4801 anupam.sin 80 
     - statuses
483 rajveer 81 
     - from_date
82 
     - to_date
83 
     - warehouse_id
94 ashish 84 
    """
85 
    pass
86 
 
4133 chandransh 87 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
88 
    """
89 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
90 
    Pass the status as null and the limit as 0 to ignore them.
91 
 
92 
    Parameters:
93 
     - statuses
94 
     - offset
95 
     - limit
96 
     - warehouse_id
97 
    """
98 
    pass
99 
 
100 
  def getOrderCount(self, statuses, warehouseId):
101 
    """
102 
    Returns the count of orders with the given statuses assigned to the given warehouse.
103 
 
104 
    Parameters:
105 
     - statuses
106 
     - warehouseId
107 
    """
108 
    pass
109 
 
999 varun.gupt 110 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
111 
    """
1132 chandransh 112 
    Returns orders within a range of their billing dates
3431 rajveer 113 
 
999 varun.gupt 114 
    Parameters:
115 
     - status
116 
     - start_billing_date
117 
     - end_billing_date
118 
     - warehouse_id
119 
    """
120 
    pass
121 
 
3451 chandransh 122 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 123 
    """
124 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 125 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
126 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 127 
 
3427 chandransh 128 
    Parameters:
129 
     - fromShippingDate
130 
     - toShippingDate
131 
     - providerId
132 
     - warehouseId
3451 chandransh 133 
     - cod
3427 chandransh 134 
    """
135 
    pass
136 
 
1382 varun.gupt 137 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
138 
    """
139 
    Returns order ids for orders which can be returned
3431 rajveer 140 
 
1382 varun.gupt 141 
    Parameters:
142 
     - customer_id
143 
     - limit
144 
    """
145 
    pass
146 
 
147 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
148 
    """
149 
    Returns order ids for orders which can be cancelled
3431 rajveer 150 
 
1382 varun.gupt 151 
    Parameters:
152 
     - customer_id
153 
     - limit
154 
    """
155 
    pass
156 
 
483 rajveer 157 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 158 
    """
159 
    Parameters:
483 rajveer 160 
     - orderId
161 
     - status
162 
     - description
94 ashish 163 
    """
164 
    pass
165 
 
1528 ankur.sing 166 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 167 
    """
1528 ankur.sing 168 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
169 
    only user who owns the transaction can view its order details.
3431 rajveer 170 
 
94 ashish 171 
    Parameters:
172 
     - transactionId
1528 ankur.sing 173 
     - customerId
94 ashish 174 
    """
175 
    pass
176 
 
3014 chandransh 177 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 178 
    """
3014 chandransh 179 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
180 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 181 
 
94 ashish 182 
    Parameters:
483 rajveer 183 
     - customerId
184 
     - from_date
185 
     - to_date
3014 chandransh 186 
     - statuses
94 ashish 187 
    """
188 
    pass
189 
 
483 rajveer 190 
  def createOrder(self, order):
94 ashish 191 
    """
192 
    Parameters:
483 rajveer 193 
     - order
94 ashish 194 
    """
195 
    pass
196 
 
483 rajveer 197 
  def getOrder(self, id):
94 ashish 198 
    """
199 
    Parameters:
483 rajveer 200 
     - id
94 ashish 201 
    """
202 
    pass
203 
 
483 rajveer 204 
  def getLineItemsForOrder(self, orderId):
94 ashish 205 
    """
206 
    Parameters:
483 rajveer 207 
     - orderId
94 ashish 208 
    """
209 
    pass
210 
 
4999 phani.kuma 211 
  def getOrderList(self, order_ids):
212 
    """
213 
    Parameters:
214 
     - order_ids
215 
    """
216 
    pass
217 
 
5386 phani.kuma 218 
  def getOrderListForVendor(self, order_ids, vendorId):
219 
    """
220 
    Parameters:
221 
     - order_ids
222 
     - vendorId
223 
    """
224 
    pass
225 
 
1528 ankur.sing 226 
  def getOrderForCustomer(self, orderId, customerId):
227 
    """
228 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
229 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 230 
 
1528 ankur.sing 231 
    Parameters:
232 
     - orderId
233 
     - customerId
234 
    """
235 
    pass
236 
 
4444 rajveer 237 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 238 
    """
239 
    Parameters:
4394 rajveer 240 
     - type
4444 rajveer 241 
     - warehouseId
4394 rajveer 242 
     - status
243 
     - timestamp
3064 chandransh 244 
    """
245 
    pass
246 
 
4444 rajveer 247 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 248 
    """
249 
    Parameters:
250 
     - type
4444 rajveer 251 
     - warehouseId
4394 rajveer 252 
     - description
3064 chandransh 253 
    """
254 
    pass
255 
 
4444 rajveer 256 
  def markAlertsAsSeen(self, warehouseId):
257 
    """
258 
    Parameters:
259 
     - warehouseId
260 
    """
261 
    pass
262 
 
3064 chandransh 263 
  def getValidOrderCount(self, ):
264 
    """
265 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
266 
    """
267 
    pass
268 
 
269 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
270 
    """
271 
    Returns the number of distinct customers who have done successful transactions
272 
    """
273 
    pass
274 
 
275 
  def getValidOrdersAmountRange(self, ):
276 
    """
277 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
278 
    List contains two values, first minimum amount and second maximum amount.
279 
    """
280 
    pass
281 
 
5874 rajveer 282 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 283 
    """
284 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
285 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 286 
 
3064 chandransh 287 
    Parameters:
288 
     - limit
5874 rajveer 289 
     - onlyStore
3064 chandransh 290 
    """
291 
    pass
292 
 
1220 chandransh 293 
  def batchOrders(self, warehouseId):
294 
    """
295 
    Create a batch of all the pending orders for the given warehouse.
296 
    The returned list is orderd by created_timestamp.
297 
    If there are no pending orders, an empty list is returned.
3431 rajveer 298 
 
1220 chandransh 299 
    Parameters:
300 
     - warehouseId
301 
    """
302 
    pass
303 
 
1208 chandransh 304 
  def markOrderAsOutOfStock(self, orderId):
305 
    """
306 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 307 
 
1208 chandransh 308 
    Parameters:
309 
     - orderId
310 
    """
311 
    pass
312 
 
3064 chandransh 313 
  def verifyOrder(self, orderId):
759 chandransh 314 
    """
3064 chandransh 315 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
316 
    timestamp. It is intended to be used for COD orders but can be harmlessly
317 
    used for all other orders as well.
318 
    Throws an exception if no such order exists.
3431 rajveer 319 
 
759 chandransh 320 
    Parameters:
3064 chandransh 321 
     - orderId
322 
    """
323 
    pass
324 
 
325 
  def acceptOrder(self, orderId):
326 
    """
327 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
328 
    given order is not a COD order, it also captures the payment if the same has
329 
    not been captured.
330 
    Throws an exception if no such order exists.
3431 rajveer 331 
 
3064 chandransh 332 
    Parameters:
333 
     - orderId
334 
    """
335 
    pass
336 
 
7190 amar.kumar 337 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 338 
    """
339 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 340 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 341 
    the IMEI no. if a -1 is supplied.
342 
    Also, it generates an invoice number for the order, marks the order as
343 
    BILLED and sets the billing timestamp.
344 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 345 
 
3064 chandransh 346 
    Parameters:
347 
     - orderId
4283 anupam.sin 348 
     - invoice_number
4658 mandeep.dh 349 
     - serialNumber
3064 chandransh 350 
     - itemNumber
7190 amar.kumar 351 
     - freebieWarehouseId
4283 anupam.sin 352 
     - billed_by
353 
     - jacketNumber
3064 chandransh 354 
     - billingType
5110 mandeep.dh 355 
     - fulfilmentWarehouseId
4763 rajveer 356 
     - authorize
3064 chandransh 357 
    """
358 
    pass
359 
 
6756 amar.kumar 360 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 361 
    """
362 
    Add the invoice number to the order.
363 
 
364 
    Parameters:
365 
     - orderId
366 
     - invoiceNumber
4763 rajveer 367 
     - color
6756 amar.kumar 368 
     - serialNumber
369 
     - itemNumber
4579 rajveer 370 
    """
371 
    pass
372 
 
4910 phani.kuma 373 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 374 
    """
375 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 376 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 377 
 
378 
    Parameters:
379 
     - warehouseId
380 
     - providerId
381 
     - cod
4910 phani.kuma 382 
     - orderIds
4410 rajveer 383 
    """
384 
    pass
385 
 
5713 rajveer 386 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 387 
    """
388 
    Parameters:
389 
     - providerId
390 
     - orderIds
5713 rajveer 391 
     - awbs
5676 rajveer 392 
    """
393 
    pass
394 
 
4910 phani.kuma 395 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 396 
    """
4910 phani.kuma 397 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
398 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 399 
 
3064 chandransh 400 
    Parameters:
759 chandransh 401 
     - providerId
4910 phani.kuma 402 
     - pickupDetails
759 chandransh 403 
    """
404 
    pass
405 
 
4910 phani.kuma 406 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 407 
    """
408 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 409 
 
1113 chandransh 410 
    Parameters:
411 
     - providerId
412 
    """
413 
    pass
414 
 
1132 chandransh 415 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
416 
    """
417 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
418 
    the name of the receiver.
419 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 420 
 
1132 chandransh 421 
    Parameters:
422 
     - providerId
423 
     - deliveredOrders
424 
    """
425 
    pass
426 
 
4910 phani.kuma 427 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 428 
    """
4910 phani.kuma 429 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 430 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 431 
 
1135 chandransh 432 
    Parameters:
433 
     - providerId
434 
     - returnedOrders
435 
    """
436 
    pass
437 
 
4910 phani.kuma 438 
  def getRTOrders(self, providerId):
439 
    """
440 
    Returns a list of orders that were returned by courier.
441 
 
442 
    Parameters:
443 
     - providerId
444 
    """
445 
    pass
446 
 
1246 chandransh 447 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
448 
    """
449 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 450 
 
1246 chandransh 451 
    Parameters:
452 
     - providerId
453 
     - undeliveredOrders
454 
    """
455 
    pass
456 
 
4910 phani.kuma 457 
  def getNonDeliveredOrdersbyCourier(self, providerId):
458 
    """
459 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
460 
 
461 
    Parameters:
462 
     - providerId
463 
    """
464 
    pass
465 
 
466 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
467 
    """
468 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
469 
 
470 
    Parameters:
471 
     - providerId
472 
     - local_connected_orders
473 
    """
474 
    pass
475 
 
476 
  def getOrdersNotLocalConnected(self, providerId):
477 
    """
478 
    Returns a list of orders that were picked up or shipped but pending local connection.
479 
 
480 
    Parameters:
481 
     - providerId
482 
    """
483 
    pass
484 
 
485 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
486 
    """
487 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
488 
 
489 
    Parameters:
490 
     - providerId
491 
     - destination_city_reached_orders
492 
    """
493 
    pass
494 
 
495 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
496 
    """
497 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
498 
 
499 
    Parameters:
500 
     - providerId
501 
     - first_atdl_orders
502 
    """
503 
    pass
504 
 
1408 ankur.sing 505 
  def getUndeliveredOrders(self, providerId, warehouseId):
506 
    """
507 
    Returns the list of orders whose delivery time has passed but have not been
508 
    delivered yet for the given provider and warehouse. To get a complete list of
509 
    undelivered orders, pass them as -1.
510 
    Returns an empty list if no such orders exist.
3431 rajveer 511 
 
1408 ankur.sing 512 
    Parameters:
513 
     - providerId
514 
     - warehouseId
515 
    """
516 
    pass
517 
 
4783 phani.kuma 518 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
519 
    """
520 
    Returns the list of orders whose expected delivery date has passed but have not been
521 
    delivered yet.
522 
    Returns an empty list if no such orders exist.
523 
    """
524 
    pass
525 
 
2536 chandransh 526 
  def toggleDOAFlag(self, orderId):
527 
    """
528 
    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.
529 
    Returns the final flag status.
530 
    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 531 
 
2536 chandransh 532 
    Parameters:
533 
     - orderId
534 
    """
535 
    pass
1886 ankur.sing 536 
 
4712 rajveer 537 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
538 
    """
539 
    Parameters:
540 
     - orderId
541 
     - deliveryTimestamp
542 
     - receiver
543 
    """
544 
    pass
545 
 
5553 rajveer 546 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
547 
    """
548 
    Parameters:
549 
     - orderId
550 
     - deliveryTimestamp
551 
    """
552 
    pass
553 
 
4454 rajveer 554 
  def markOrderDoaRequestReceived(self, orderId):
555 
    """
556 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
557 
 
558 
    Parameters:
559 
     - orderId
560 
    """
561 
    pass
562 
 
563 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
564 
    """
565 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
566 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
567 
 
568 
    Parameters:
569 
     - orderId
570 
     - isAuthorized
571 
    """
572 
    pass
573 
 
4488 rajveer 574 
  def markOrderReturnRequestReceived(self, orderId):
575 
    """
576 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
577 
 
578 
    Parameters:
579 
     - orderId
580 
    """
581 
    pass
582 
 
583 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
584 
    """
585 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
586 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
587 
 
588 
    Parameters:
589 
     - orderId
590 
     - isAuthorized
591 
    """
592 
    pass
593 
 
4579 rajveer 594 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 595 
    """
596 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 597 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
598 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 599 
    For any other status, it returns false.
600 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 601 
 
2536 chandransh 602 
    Parameters:
603 
     - orderId
4579 rajveer 604 
     - providerId
2536 chandransh 605 
    """
606 
    pass
607 
 
4602 rajveer 608 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 609 
    """
4452 rajveer 610 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 611 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
612 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
613 
    	3. Returns true
2591 chandransh 614 
    If the order is in any other status, it returns false.
2536 chandransh 615 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 616 
 
2536 chandransh 617 
    Parameters:
618 
     - orderId
619 
     - pickupNumber
4602 rajveer 620 
     - providerId
2536 chandransh 621 
    """
622 
    pass
623 
 
2764 chandransh 624 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
625 
    """
626 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 627 
 
2764 chandransh 628 
    Parameters:
629 
     - providerId
630 
     - pickupDetails
631 
    """
632 
    pass
633 
 
4910 phani.kuma 634 
  def getDoasNotPickedUp(self, providerId):
635 
    """
636 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
637 
 
638 
    Parameters:
639 
     - providerId
640 
    """
641 
    pass
642 
 
4741 phani.kuma 643 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
644 
    """
645 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
646 
 
647 
    Parameters:
648 
     - providerId
649 
     - pickupDetails
650 
    """
651 
    pass
652 
 
4910 phani.kuma 653 
  def getReturnOrdersNotPickedUp(self, providerId):
654 
    """
655 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
656 
 
657 
    Parameters:
658 
     - providerId
659 
    """
660 
    pass
661 
 
4479 rajveer 662 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 663 
    """
4452 rajveer 664 
    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 665 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 666 
    If the order is in any other state, it returns false.
667 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 668 
 
2591 chandransh 669 
    Parameters:
670 
     - orderId
4479 rajveer 671 
     - receiveCondition
2591 chandransh 672 
    """
673 
    pass
2536 chandransh 674 
 
2591 chandransh 675 
  def validateDoa(self, orderId, isValid):
676 
    """
4452 rajveer 677 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 678 
    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 679 
    If the order is in any other state, it returns false.
680 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 681 
 
2591 chandransh 682 
    Parameters:
683 
     - orderId
684 
     - isValid
685 
    """
686 
    pass
687 
 
4495 rajveer 688 
  def validateReturnProduct(self, orderId, isUsable):
689 
    """
690 
    Parameters:
691 
     - orderId
692 
     - isUsable
693 
    """
694 
    pass
695 
 
2616 chandransh 696 
  def reshipOrder(self, orderId):
697 
    """
4484 rajveer 698 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 699 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 700 
    	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 701 
 
702 
    If the order is in DOA_CERT_VALID state, it does the following:
703 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
704 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 705 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 706 
 
2616 chandransh 707 
    Returns the id of the newly created order.
3431 rajveer 708 
 
2616 chandransh 709 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 710 
 
2616 chandransh 711 
    Parameters:
712 
     - orderId
713 
    """
714 
    pass
2591 chandransh 715 
 
3226 chandransh 716 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 717 
    """
4484 rajveer 718 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 719 
    	1. Creates a refund request for batch processing.
720 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 721 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 722 
 
2616 chandransh 723 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
724 
    	1. Creates a refund request for batch processing.
3226 chandransh 725 
    	2. Cancels the reservation of the item in the warehouse.
726 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 727 
 
3226 chandransh 728 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
729 
    	1. Cancels the reservation of the item in the warehouse.
730 
    	2. Marks the current order as CANCELED.
731 
 
732 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
733 
 
2616 chandransh 734 
    Returns True if it is successful, False otherwise.
3431 rajveer 735 
 
2616 chandransh 736 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 737 
 
2616 chandransh 738 
    Parameters:
739 
     - orderId
3226 chandransh 740 
     - refundedBy
741 
     - reason
2616 chandransh 742 
    """
743 
    pass
744 
 
2690 chandransh 745 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
746 
    """
747 
    Get all return orders created between the from and to dates for the given warehouse.
748 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 749 
 
2690 chandransh 750 
    Parameters:
751 
     - warehouseId
752 
     - fromDate
753 
     - toDate
754 
    """
755 
    pass
2616 chandransh 756 
 
5481 phani.kuma 757 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
758 
    """
759 
    Get all return orders created between the from and to dates.
760 
 
761 
    Parameters:
762 
     - onlyNotProcessed
763 
     - fromDate
764 
     - toDate
765 
    """
766 
    pass
767 
 
2700 chandransh 768 
  def getReturnOrder(self, id):
769 
    """
770 
    Returns the ReturnOrder corresponding to the given id.
771 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 772 
 
2700 chandransh 773 
    Parameters:
774 
     - id
775 
    """
776 
    pass
777 
 
2690 chandransh 778 
  def processReturn(self, returnOrderId):
779 
    """
780 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 781 
 
2690 chandransh 782 
    Parameters:
783 
     - returnOrderId
784 
    """
785 
    pass
786 
 
3451 chandransh 787 
  def updateWeight(self, orderId, weight):
788 
    """
789 
    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 790 
 
3451 chandransh 791 
    Parameters:
792 
     - orderId
793 
     - weight
794 
    """
795 
    pass
796 
 
3469 chandransh 797 
  def changeItem(self, orderId, itemId):
798 
    """
799 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
800 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 801 
 
3469 chandransh 802 
    Parameters:
803 
     - orderId
804 
     - itemId
805 
    """
806 
    pass
807 
 
808 
  def shiftToWarehouse(self, orderId, warehouseId):
809 
    """
810 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
811 
 
812 
    Parameters:
813 
     - orderId
814 
     - warehouseId
815 
    """
816 
    pass
817 
 
4647 rajveer 818 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 819 
    """
820 
    Adds the given delay reason to the given order.
3986 chandransh 821 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 822 
    Raises an exception if no order with the given id can be found.
3469 chandransh 823 
 
3553 chandransh 824 
    Parameters:
825 
     - orderId
826 
     - delayReason
3986 chandransh 827 
     - furtherDelay
4647 rajveer 828 
     - delayReasonText
3553 chandransh 829 
    """
830 
    pass
831 
 
3956 chandransh 832 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
833 
    """
834 
    Marks the COD orders with given AWB nos. as having been processed.
835 
    Updates the captured amount for the corresponding payment.
3553 chandransh 836 
 
3956 chandransh 837 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
838 
    1. There is no order corresponding to an AWB number.
839 
    2. The captured amount for a payment exceeds the total payment.
840 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
841 
 
842 
    Parameters:
843 
     - collectedAmountMap
844 
     - xferBy
845 
     - xferTxnId
846 
     - xferDate
847 
    """
848 
    pass
849 
 
4008 mandeep.dh 850 
  def getTransactionsRequiringExtraProcessing(self, category):
851 
    """
4065 mandeep.dh 852 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 853 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 854 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 855 
 
4008 mandeep.dh 856 
    Parameters:
857 
     - category
858 
    """
859 
    pass
860 
 
861 
  def markTransactionAsProcessed(self, transactionId, category):
862 
    """
863 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 864 
    It essentially deletes the transaction id record for a particular
865 
    processing type category (if present) from DB.
866 
    This is currently used by CRM application.
4008 mandeep.dh 867 
 
868 
    Parameters:
869 
     - transactionId
870 
     - category
871 
    """
872 
    pass
873 
 
4018 chandransh 874 
  def getItemWiseRiskyOrdersCount(self, ):
875 
    """
876 
    Returns a map containing the number of risky orders keyed by item id. A risky order
877 
    is defined as one whose shipping date is about to expire.
878 
    """
879 
    pass
4008 mandeep.dh 880 
 
4295 varun.gupt 881 
  def getOrdersForItemIds(self, itemIds):
882 
    """
883 
    Returns a list of all orders which have items with given id
884 
 
885 
    Parameters:
886 
     - itemIds
887 
    """
888 
    pass
889 
 
4247 rajveer 890 
  def markOrderCancellationRequestReceived(self, orderId):
891 
    """
892 
    Mark order as cancellation request received. If customer sends request of cancellation of
893 
    a particular order, this method will be called. It will just change status of the order
894 
    depending on its current status. It also records the previous status, so that we can move
895 
    back to that status if cancellation request is denied.
4018 chandransh 896 
 
4247 rajveer 897 
    Parameters:
898 
     - orderId
899 
    """
900 
    pass
901 
 
902 
  def markOrderCancellationRequestConfirmed(self, orderId):
903 
    """
904 
    If we decide to to cancel order, CRM will call this method to move the status of order to
905 
    cancellation request confirmed. After this OM will be able to cancel the order.
906 
 
907 
    Parameters:
908 
     - orderId
909 
    """
910 
    pass
911 
 
912 
  def markOrderCancellationRequestDenied(self, orderId):
913 
    """
914 
    If we decide to not to cancel order, we will move the order ro previous status.
915 
 
916 
    Parameters:
917 
     - orderId
918 
    """
919 
    pass
920 
 
4258 rajveer 921 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 922 
    """
4258 rajveer 923 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
924 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 925 
 
926 
    Parameters:
4258 rajveer 927 
     - transactionId
4247 rajveer 928 
    """
929 
    pass
930 
 
4259 anupam.sin 931 
  def refundTransaction(self, transactionId, refundedBy, reason):
932 
    """
933 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
934 
    need to be cancelled
4247 rajveer 935 
 
4259 anupam.sin 936 
    Parameters:
937 
     - transactionId
938 
     - refundedBy
939 
     - reason
940 
    """
941 
    pass
942 
 
4324 mandeep.dh 943 
  def updateShipmentAddress(self, orderId, addressId):
944 
    """
945 
    Updates shipment address of an order. Delivery and shipping date estimates
946 
    etc. are also updated here.
947 
 
948 
    Throws TransactionServiceException in case address change is not
949 
    possible due to certain reasons such as new pincode in address is
950 
    not serviceable etc.
951 
 
952 
    Parameters:
953 
     - orderId
954 
     - addressId
955 
    """
956 
    pass
957 
 
4285 rajveer 958 
  def acceptOrdersForItemId(self, itemId, inventory):
959 
    """
960 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
961 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 962 
 
4285 rajveer 963 
    Parameters:
964 
     - itemId
965 
     - inventory
966 
    """
967 
    pass
968 
 
4369 rajveer 969 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 970 
    """
971 
    Parameters:
972 
     - vendorId
973 
     - itemId
974 
     - quantity
975 
     - estimate
4369 rajveer 976 
     - isReminder
4303 rajveer 977 
    """
978 
    pass
4285 rajveer 979 
 
4369 rajveer 980 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 981 
    """
982 
    Parameters:
983 
     - vendorId
984 
     - itemId
985 
     - quantity
986 
     - estimate
4369 rajveer 987 
     - isReminder
4303 rajveer 988 
    """
989 
    pass
990 
 
4369 rajveer 991 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 992 
    """
993 
    Parameters:
994 
     - vendorId
995 
     - itemId
996 
     - quantity
997 
     - estimate
4369 rajveer 998 
     - isReminder
4303 rajveer 999 
    """
1000 
    pass
1001 
 
4369 rajveer 1002 
  def markOrdersAsTimeout(self, vendorId):
1003 
    """
1004 
    Parameters:
1005 
     - vendorId
1006 
    """
1007 
    pass
4303 rajveer 1008 
 
4662 rajveer 1009 
  def markOrderAsLostInTransit(self, orderId):
1010 
    """
1011 
    Mark order as LOST_IN_TRANSIT
1012 
 
1013 
    Parameters:
1014 
     - orderId
1015 
    """
1016 
    pass
1017 
 
4386 anupam.sin 1018 
  def getOrderForAwb(self, awb):
1019 
    """
1020 
    Returns the order corresponding to an AWB number
4369 rajveer 1021 
 
4386 anupam.sin 1022 
    Parameters:
1023 
     - awb
1024 
    """
1025 
    pass
1026 
 
4910 phani.kuma 1027 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1028 
    """
4910 phani.kuma 1029 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1030 
 
4506 phani.kuma 1031 
    Parameters:
1032 
     - logistics_provider_id
4910 phani.kuma 1033 
     - order_status_list
4506 phani.kuma 1034 
    """
1035 
    pass
1036 
 
4600 varun.gupt 1037 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1038 
    """
1039 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1040 
 
4600 varun.gupt 1041 
    Parameters:
1042 
     - vendorId
1043 
     - billingDateFrom
1044 
     - billingDateTo
1045 
    """
1046 
    pass
1047 
 
4607 rajveer 1048 
  def getSlippedSippingDateOrders(self, ):
1049 
    pass
1050 
 
4709 rajveer 1051 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1052 
    """
1053 
    Parameters:
1054 
     - cancelDateFrom
1055 
     - cancelDateTo
1056 
    """
1057 
    pass
1058 
 
4600 varun.gupt 1059 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1060 
    """
1061 
    Parameters:
1062 
     - mapAWBAndAmount
1063 
    """
1064 
    pass
1065 
 
4905 varun.gupt 1066 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1067 
    """
1068 
    Parameters:
1069 
     - settlementDate
1070 
     - paymentGatewayId
4905 varun.gupt 1071 
     - referenceId
4600 varun.gupt 1072 
     - serviceTax
1073 
     - otherCharges
1074 
     - netCollection
1075 
    """
1076 
    pass
1077 
 
1078 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1079 
    """
1080 
    Parameters:
1081 
     - settlementId
1082 
     - settlementDate
1083 
     - transactionDateFrom
1084 
     - transactionDateTo
1085 
     - amount
1086 
    """
1087 
    pass
1088 
 
5386 phani.kuma 1089 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1090 
    """
1091 
    Parameters:
5189 varun.gupt 1092 
     - referenceId
1093 
     - isRefund
4600 varun.gupt 1094 
    """
1095 
    pass
1096 
 
5386 phani.kuma 1097 
  def getSettlementForCod(self, orderId, isRefund):
1098 
    """
1099 
    Parameters:
1100 
     - orderId
1101 
     - isRefund
1102 
    """
1103 
    pass
1104 
 
4600 varun.gupt 1105 
  def getEBSSettlementSummaries(self, ):
1106 
    pass
1107 
 
1108 
  def markEBSSettlementUploaded(self, settlementId):
1109 
    """
1110 
    Parameters:
1111 
     - settlementId
1112 
    """
1113 
    pass
1114 
 
1115 
  def getEBSSettlementDate(self, settlementId):
1116 
    """
1117 
    Parameters:
1118 
     - settlementId
1119 
    """
1120 
    pass
1121 
 
4715 varun.gupt 1122 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1123 
    """
1124 
    Parameters:
1125 
     - settlementDateFrom
1126 
     - settlementDateTo
1127 
     - isRefund
1128 
    """
1129 
    pass
4600 varun.gupt 1130 
 
4715 varun.gupt 1131 
  def getReshippedOrderIds(self, orderIds):
1132 
    """
1133 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1134 
 
1135 
    Parameters:
1136 
     - orderIds
1137 
    """
1138 
    pass
1139 
 
5481 phani.kuma 1140 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1141 
    """
1142 
    Parameters:
1143 
     - vendorId
5481 phani.kuma 1144 
     - onlyVendorNotPaid
1145 
     - billingDateFrom
1146 
     - billingDateTo
4875 varun.gupt 1147 
    """
1148 
    pass
4757 mandeep.dh 1149 
 
5031 varun.gupt 1150 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1151 
    """
1152 
    Parameters:
1153 
     - startDate
1154 
     - endDate
1155 
    """
1156 
    pass
4875 varun.gupt 1157 
 
5067 varun.gupt 1158 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1159 
    """
1160 
    Parameters:
1161 
     - status
1162 
     - startDatetime
1163 
     - endDatetime
1164 
    """
1165 
    pass
5031 varun.gupt 1166 
 
5348 anupam.sin 1167 
  def updateCODAgent(self, agent, orderId):
1168 
    """
1169 
    Updates the agent who handled the COD verification call
1170 
 
1171 
    Parameters:
1172 
     - agent
1173 
     - orderId
1174 
    """
1175 
    pass
1176 
 
5099 varun.gupt 1177 
  def updateOrderAsPaidToVendor(self, orderId):
1178 
    """
1179 
    Parameters:
1180 
     - orderId
1181 
    """
1182 
    pass
5067 varun.gupt 1183 
 
5386 phani.kuma 1184 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1185 
    """
1186 
    Parameters:
1187 
     - orderId
1188 
    """
1189 
    pass
1190 
 
5208 varun.gupt 1191 
  def getRefundedOrdersMarkedPaid(self, ):
1192 
    pass
5099 varun.gupt 1193 
 
5447 anupam.sin 1194 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1195 
    """
1196 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1197 
 
5447 anupam.sin 1198 
 
1199 
    Parameters:
1200 
     - minOrderId
1201 
     - maxOrderId
1202 
    """
1203 
    pass
1204 
 
5527 anupam.sin 1205 
  def getAllAttributesForOrderId(self, orderId):
1206 
    """
1207 
    gets all attributes for a given orderId
5447 anupam.sin 1208 
 
5527 anupam.sin 1209 
    Parameters:
1210 
     - orderId
1211 
    """
1212 
    pass
1213 
 
5676 rajveer 1214 
  def setOrderAttributes(self, orderId, attributes):
1215 
    """
1216 
    sets attributes for an order
1217 
 
1218 
    Parameters:
1219 
     - orderId
1220 
     - attributes
1221 
    """
1222 
    pass
1223 
 
5527 anupam.sin 1224 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1225 
    """
1226 
    sets attributes for all orders in a transaction
1227 
 
1228 
    Parameters:
1229 
     - transactionId
1230 
     - attribute
1231 
    """
1232 
    pass
1233 
 
5553 rajveer 1234 
  def getReceivePendingOrders(self, storeId):
1235 
    """
1236 
    Parameters:
1237 
     - storeId
1238 
    """
1239 
    pass
5527 anupam.sin 1240 
 
5553 rajveer 1241 
  def getReceivedAtStoreOrders(self, storeId):
1242 
    """
1243 
    Parameters:
1244 
     - storeId
1245 
    """
1246 
    pass
1247 
 
5713 rajveer 1248 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1249 
    """
1250 
    Parameters:
1251 
     - storeId
1252 
     - fromDate
1253 
     - toDate
1254 
     - onlyCod
1255 
    """
1256 
    pass
1257 
 
5833 rajveer 1258 
  def getOrderAttributeValue(self, orderId, attributeName):
1259 
    """
1260 
    Parameters:
1261 
     - orderId
1262 
     - attributeName
1263 
    """
1264 
    pass
1265 
 
6019 rajveer 1266 
  def changeJacketNumber(self, orderId, jacketNumber):
1267 
    """
1268 
    Parameters:
1269 
     - orderId
1270 
     - jacketNumber
1271 
    """
1272 
    pass
1273 
 
1274 
  def markOrderAsRtoInTransit(self, orderId):
1275 
    """
1276 
    Parameters:
1277 
     - orderId
1278 
    """
1279 
    pass
1280 
 
5593 mandeep.dh 1281 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1282 
    """
1283 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1284 
    invoked while scanning IN of items.
5553 rajveer 1285 
 
5593 mandeep.dh 1286 
    Parameters:
1287 
     - itemId
1288 
     - quantity
1289 
     - fulfilmentWarehouseId
1290 
     - billingWarehouseId
1291 
    """
1292 
    pass
1293 
 
6000 mandeep.dh 1294 
  def createRechargeOrder(self, rechargeOrder):
1295 
    """
1296 
    Parameters:
1297 
     - rechargeOrder
1298 
    """
1299 
    pass
5593 mandeep.dh 1300 
 
6031 rajveer 1301 
  def getRechargeOrder(self, rechargeRrderId):
1302 
    """
1303 
    Parameters:
1304 
     - rechargeRrderId
1305 
    """
1306 
    pass
1307 
 
1308 
  def getRechargeOrders(self, userId):
1309 
    """
1310 
    Parameters:
1311 
     - userId
1312 
    """
1313 
    pass
1314 
 
6000 mandeep.dh 1315 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1316 
    """
1317 
    Parameters:
1318 
     - rechargeOrderId
1319 
     - rechargeOrderStatus
1320 
    """
1321 
    pass
1322 
 
6031 rajveer 1323 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1324 
    """
1325 
    Parameters:
6031 rajveer 1326 
     - rechargeOrderId
6000 mandeep.dh 1327 
    """
1328 
    pass
1329 
 
6031 rajveer 1330 
  def getUserWallet(self, userId):
6000 mandeep.dh 1331 
    """
1332 
    Parameters:
6031 rajveer 1333 
     - userId
6000 mandeep.dh 1334 
    """
1335 
    pass
1336 
 
6031 rajveer 1337 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1338 
    """
1339 
    Parameters:
6031 rajveer 1340 
     - userId
6000 mandeep.dh 1341 
    """
1342 
    pass
1343 
 
6050 anupam.sin 1344 
  def getRechargeOrdersForTransaction(self, txnId):
1345 
    """
1346 
    Returns a recharge order for a given transactionId
1347 
 
1348 
    Parameters:
1349 
     - txnId
1350 
    """
1351 
    pass
1352 
 
6206 rajveer 1353 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1354 
    """
1355 
    Parameters:
1356 
     - rechargeType
6206 rajveer 1357 
     - onlyActive
6048 rajveer 1358 
    """
1359 
    pass
6000 mandeep.dh 1360 
 
6049 rajveer 1361 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1362 
    """
1363 
    Parameters:
6049 rajveer 1364 
     - rechargeType
6048 rajveer 1365 
     - deviceNumber
1366 
    """
1367 
    pass
1368 
 
6591 anupam.sin 1369 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1370 
    """
1371 
    Parameters:
1372 
     - rechargeType
1373 
     - deviceNumber
6307 anupam.sin 1374 
     - userSelectedProviderId
6591 anupam.sin 1375 
     - clientAddress
6269 rajveer 1376 
    """
1377 
    pass
1378 
 
6094 rajveer 1379 
  def getRechargeOrdersForDevice(self, deviceNumber):
1380 
    """
1381 
    Parameters:
1382 
     - deviceNumber
1383 
    """
1384 
    pass
6048 rajveer 1385 
 
6094 rajveer 1386 
  def addAmountToWallet(self, userId, orderId, amount):
1387 
    """
1388 
    Parameters:
1389 
     - userId
1390 
     - orderId
1391 
     - amount
1392 
    """
1393 
    pass
1394 
 
6188 rajveer 1395 
  def getRechargeStatistics(self, ):
1396 
    pass
1397 
 
6154 rajveer 1398 
  def getRechargeOrdersForStatus(self, status):
1399 
    """
1400 
    Parameters:
1401 
     - status
1402 
    """
1403 
    pass
6094 rajveer 1404 
 
6159 rajveer 1405 
  def getPlansForOperator(self, operatorId):
1406 
    """
1407 
    Parameters:
1408 
     - operatorId
1409 
    """
1410 
    pass
6154 rajveer 1411 
 
6307 anupam.sin 1412 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1413 
    """
1414 
    Returns denominations for a given operator and circle
6159 rajveer 1415 
 
6289 anupam.sin 1416 
    Parameters:
1417 
     - operatorId
6307 anupam.sin 1418 
     - circleCode
6289 anupam.sin 1419 
     - denominationType
1420 
    """
1421 
    pass
1422 
 
6371 rajveer 1423 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1424 
    """
1425 
    Parameters:
1426 
     - operatorId
1427 
     - circleId
1428 
     - isAvailable
1429 
    """
1430 
    pass
6289 anupam.sin 1431 
 
6389 rajveer 1432 
  def getAvailableEmiSchemes(self, ):
1433 
    pass
6371 rajveer 1434 
 
6389 rajveer 1435 
  def getMiscCharges(self, transactionId):
1436 
    """
1437 
    Parameters:
1438 
     - transactionId
1439 
    """
1440 
    pass
1441 
 
6507 anupam.sin 1442 
  def refundRechargeOrder(self, rechargeOrderId):
1443 
    """
1444 
    Parameters:
1445 
     - rechargeOrderId
1446 
    """
1447 
    pass
6389 rajveer 1448 
 
6821 amar.kumar 1449 
  def getPhysicalOrders(self, fromDate, toDate):
1450 
    """
1451 
    Parameters:
1452 
     - fromDate
1453 
     - toDate
1454 
    """
1455 
    pass
6507 anupam.sin 1456 
 
6906 rajveer 1457 
  def getDocument(self, docType, docSource):
1458 
    """
1459 
    Parameters:
1460 
     - docType
1461 
     - docSource
1462 
    """
1463 
    pass
6821 amar.kumar 1464 
 
6985 anupam.sin 1465 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1466 
    """
1467 
    Parameters:
1468 
     - orderId
1469 
     - line1
1470 
     - line2
1471 
     - city
1472 
     - state
1473 
     - pin
1474 
    """
1475 
    pass
6906 rajveer 1476 
 
7075 rajveer 1477 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 1478 
    """
1479 
    Parameters:
1480 
     - orderId
7075 rajveer 1481 
     - userId
6988 rajveer 1482 
    """
1483 
    pass
6985 anupam.sin 1484 
 
7026 rajveer 1485 
  def receiveUpdatesForRedExpress(self, awbNumber):
1486 
    """
1487 
    Parameters:
1488 
     - awbNumber
1489 
    """
1490 
    pass
6988 rajveer 1491 
 
7073 anupam.sin 1492 
  def createRechargeTransaction(self, thriftRechargeTransaction):
1493 
    """
1494 
    Parameters:
1495 
     - thriftRechargeTransaction
1496 
    """
1497 
    pass
7026 rajveer 1498 
 
7085 rajveer 1499 
  def getRechargeTransactions(self, storeId):
1500 
    """
1501 
    Parameters:
1502 
     - storeId
1503 
    """
1504 
    pass
1505 
 
7151 amit.gupta 1506 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
1507 
    """
1508 
    Parameters:
1509 
     - storeId
1510 
     - startDate
1511 
     - endDate
1512 
     - status
1513 
    """
1514 
    pass
1515 
 
7080 anupam.sin 1516 
  def getRechargeTransaction(self, rechargeId):
1517 
    """
1518 
    Parameters:
1519 
     - rechargeId
1520 
    """
1521 
    pass
7073 anupam.sin 1522 
 
7080 anupam.sin 1523 
  def getFRCs(self, circleId, operatorId):
1524 
    """
1525 
    Parameters:
1526 
     - circleId
1527 
     - operatorId
1528 
    """
1529 
    pass
1530 
 
7096 anupam.sin 1531 
  def getHotspotStore(self, id, hotspotid):
1532 
    """
1533 
    Parameters:
1534 
     - id
1535 
     - hotspotid
1536 
    """
1537 
    pass
7080 anupam.sin 1538 
 
7096 anupam.sin 1539 
  def getTelecomCircle(self, id, code):
1540 
    """
1541 
    Parameters:
1542 
     - id
1543 
     - code
1544 
    """
1545 
    pass
1546 
 
7109 anupam.sin 1547 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
1548 
    """
1549 
    Parameters:
1550 
     - rechargeId
1551 
    """
1552 
    pass
7096 anupam.sin 1553 
 
7190 amar.kumar 1554 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
1555 
    """
1556 
    Parameters:
1557 
     - orderId
1558 
     - splitReason
1559 
     - shippingDate
1560 
    """
1561 
    pass
1562 
 
7172 anupam.sin 1563 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 1564 
    """
1565 
    Parameters:
1566 
     - number
7172 anupam.sin 1567 
     - storeId
7169 anupam.sin 1568 
    """
1569 
    pass
7109 anupam.sin 1570 
 
7169 anupam.sin 1571 
  def updateHotspotStorePassword(self, storeId, password):
1572 
    """
1573 
    Parameters:
1574 
     - storeId
1575 
     - password
1576 
    """
1577 
    pass
1578 
 
7285 rajveer 1579 
  def topupCompanyWallet(self, companyId, amount):
7263 anupam.sin 1580 
    """
1581 
    Parameters:
7285 rajveer 1582 
     - companyId
1583 
     - amount
7263 anupam.sin 1584 
    """
1585 
    pass
7169 anupam.sin 1586 
 
7285 rajveer 1587 
  def getWalletBalanceForCompany(self, companyId):
1588 
    """
1589 
    Parameters:
1590 
     - companyId
1591 
    """
7267 anupam.sin 1592 
    pass
7263 anupam.sin 1593 
 
7285 rajveer 1594 
  def getSourceDetail(self, source):
7267 anupam.sin 1595 
    """
1596 
    Parameters:
7285 rajveer 1597 
     - source
7267 anupam.sin 1598 
    """
1599 
    pass
1600 
 
7308 rajveer 1601 
  def getAllCircles(self, ):
1602 
    pass
7267 anupam.sin 1603 
 
7308 rajveer 1604 
  def deleteFrcs(self, frcIdsToDelete):
1605 
    """
1606 
    Parameters:
1607 
     - frcIdsToDelete
1608 
    """
1609 
    pass
1610 
 
7311 kshitij.so 1611 
  def addAmazonOrder(self, amazonOrder):
1612 
    """
1613 
    Parameters:
1614 
     - amazonOrder
1615 
    """
1616 
    pass
7308 rajveer 1617 
 
7322 vikram.rag 1618 
  def updateAmazonOrderStatus(self, orderId, status):
7311 kshitij.so 1619 
    """
1620 
    Parameters:
1621 
     - orderId
1622 
     - status
1623 
    """
1624 
    pass
1625 
 
1626 
  def getAmazonOrdersShipped(self, interval):
1627 
    """
1628 
    Parameters:
1629 
     - interval
1630 
    """
1631 
    pass
1632 
 
1633 
  def getAmazonOrdersCancelled(self, interval):
1634 
    """
1635 
    Parameters:
1636 
     - interval
1637 
    """
1638 
    pass
1639 
 
7322 vikram.rag 1640 
  def getAmazonOrder(self, orderId):
1641 
    """
1642 
    Parameters:
1643 
     - orderId
1644 
    """
1645 
    pass
7311 kshitij.so 1646 
 
7322 vikram.rag 1647 
 
3376 rajveer 1648 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1649 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1650 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1651 
 
1652 
  def createTransaction(self, transaction):
1653 
    """
1654 
    Parameters:
1655 
     - transaction
1656 
    """
1657 
    self.send_createTransaction(transaction)
132 ashish 1658 
    return self.recv_createTransaction()
94 ashish 1659 
 
1660 
  def send_createTransaction(self, transaction):
1661 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1662 
    args = createTransaction_args()
1663 
    args.transaction = transaction
1664 
    args.write(self._oprot)
1665 
    self._oprot.writeMessageEnd()
1666 
    self._oprot.trans.flush()
1667 
 
1668 
  def recv_createTransaction(self, ):
1669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1670 
    if mtype == TMessageType.EXCEPTION:
1671 
      x = TApplicationException()
1672 
      x.read(self._iprot)
1673 
      self._iprot.readMessageEnd()
1674 
      raise x
1675 
    result = createTransaction_result()
1676 
    result.read(self._iprot)
1677 
    self._iprot.readMessageEnd()
3431 rajveer 1678 
    if result.success is not None:
132 ashish 1679 
      return result.success
3431 rajveer 1680 
    if result.ex is not None:
94 ashish 1681 
      raise result.ex
132 ashish 1682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1683 
 
1684 
  def getTransaction(self, id):
1685 
    """
1686 
    Parameters:
1687 
     - id
1688 
    """
1689 
    self.send_getTransaction(id)
1690 
    return self.recv_getTransaction()
1691 
 
1692 
  def send_getTransaction(self, id):
1693 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1694 
    args = getTransaction_args()
1695 
    args.id = id
1696 
    args.write(self._oprot)
1697 
    self._oprot.writeMessageEnd()
1698 
    self._oprot.trans.flush()
1699 
 
1700 
  def recv_getTransaction(self, ):
1701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1702 
    if mtype == TMessageType.EXCEPTION:
1703 
      x = TApplicationException()
1704 
      x.read(self._iprot)
1705 
      self._iprot.readMessageEnd()
1706 
      raise x
1707 
    result = getTransaction_result()
1708 
    result.read(self._iprot)
1709 
    self._iprot.readMessageEnd()
3431 rajveer 1710 
    if result.success is not None:
94 ashish 1711 
      return result.success
3431 rajveer 1712 
    if result.ex is not None:
94 ashish 1713 
      raise result.ex
1714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1715 
 
1716 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1717 
    """
1718 
    Parameters:
1719 
     - customerId
1720 
     - from_date
1721 
     - to_date
1722 
     - status
1723 
    """
1724 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1725 
    return self.recv_getTransactionsForCustomer()
1726 
 
1727 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1728 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1729 
    args = getTransactionsForCustomer_args()
1730 
    args.customerId = customerId
1731 
    args.from_date = from_date
1732 
    args.to_date = to_date
1733 
    args.status = status
1734 
    args.write(self._oprot)
1735 
    self._oprot.writeMessageEnd()
1736 
    self._oprot.trans.flush()
1737 
 
1738 
  def recv_getTransactionsForCustomer(self, ):
1739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1740 
    if mtype == TMessageType.EXCEPTION:
1741 
      x = TApplicationException()
1742 
      x.read(self._iprot)
1743 
      self._iprot.readMessageEnd()
1744 
      raise x
1745 
    result = getTransactionsForCustomer_result()
1746 
    result.read(self._iprot)
1747 
    self._iprot.readMessageEnd()
3431 rajveer 1748 
    if result.success is not None:
94 ashish 1749 
      return result.success
3431 rajveer 1750 
    if result.ex is not None:
94 ashish 1751 
      raise result.ex
1752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1753 
 
132 ashish 1754 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1755 
    """
1756 
    Parameters:
1757 
     - shoppingCartId
1758 
    """
1759 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1760 
    return self.recv_getTransactionsForShoppingCartId()
1761 
 
1762 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1763 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1764 
    args = getTransactionsForShoppingCartId_args()
1765 
    args.shoppingCartId = shoppingCartId
1766 
    args.write(self._oprot)
1767 
    self._oprot.writeMessageEnd()
1768 
    self._oprot.trans.flush()
1769 
 
1770 
  def recv_getTransactionsForShoppingCartId(self, ):
1771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1772 
    if mtype == TMessageType.EXCEPTION:
1773 
      x = TApplicationException()
1774 
      x.read(self._iprot)
1775 
      self._iprot.readMessageEnd()
1776 
      raise x
1777 
    result = getTransactionsForShoppingCartId_result()
1778 
    result.read(self._iprot)
1779 
    self._iprot.readMessageEnd()
3431 rajveer 1780 
    if result.success is not None:
132 ashish 1781 
      return result.success
3431 rajveer 1782 
    if result.ex is not None:
132 ashish 1783 
      raise result.ex
1784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1785 
 
94 ashish 1786 
  def getTransactionStatus(self, transactionId):
1787 
    """
1788 
    Parameters:
1789 
     - transactionId
1790 
    """
1791 
    self.send_getTransactionStatus(transactionId)
1792 
    return self.recv_getTransactionStatus()
1793 
 
1794 
  def send_getTransactionStatus(self, transactionId):
1795 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1796 
    args = getTransactionStatus_args()
1797 
    args.transactionId = transactionId
1798 
    args.write(self._oprot)
1799 
    self._oprot.writeMessageEnd()
1800 
    self._oprot.trans.flush()
1801 
 
1802 
  def recv_getTransactionStatus(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 = getTransactionStatus_result()
1810 
    result.read(self._iprot)
1811 
    self._iprot.readMessageEnd()
3431 rajveer 1812 
    if result.success is not None:
94 ashish 1813 
      return result.success
3431 rajveer 1814 
    if result.ex is not None:
94 ashish 1815 
      raise result.ex
1816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1817 
 
7293 anupam.sin 1818 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1819 
    """
1820 
    Parameters:
1821 
     - transactionId
1822 
     - status
1823 
     - description
5527 anupam.sin 1824 
     - pickUp
1825 
     - orderType
7293 anupam.sin 1826 
     - source
94 ashish 1827 
    """
7293 anupam.sin 1828 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType, source)
94 ashish 1829 
    return self.recv_changeTransactionStatus()
1830 
 
7293 anupam.sin 1831 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1832 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1833 
    args = changeTransactionStatus_args()
1834 
    args.transactionId = transactionId
1835 
    args.status = status
1836 
    args.description = description
5527 anupam.sin 1837 
    args.pickUp = pickUp
1838 
    args.orderType = orderType
7293 anupam.sin 1839 
    args.source = source
94 ashish 1840 
    args.write(self._oprot)
1841 
    self._oprot.writeMessageEnd()
1842 
    self._oprot.trans.flush()
1843 
 
1844 
  def recv_changeTransactionStatus(self, ):
1845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1846 
    if mtype == TMessageType.EXCEPTION:
1847 
      x = TApplicationException()
1848 
      x.read(self._iprot)
1849 
      self._iprot.readMessageEnd()
1850 
      raise x
1851 
    result = changeTransactionStatus_result()
1852 
    result.read(self._iprot)
1853 
    self._iprot.readMessageEnd()
3431 rajveer 1854 
    if result.success is not None:
94 ashish 1855 
      return result.success
3431 rajveer 1856 
    if result.ex is not None:
94 ashish 1857 
      raise result.ex
1858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1859 
 
1398 varun.gupt 1860 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1861 
    """
1862 
    Parameters:
1863 
     - transactionId
1864 
    """
1398 varun.gupt 1865 
    self.send_enqueueTransactionInfoEmail(transactionId)
1866 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1867 
 
1398 varun.gupt 1868 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1869 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1870 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1871 
    args.transactionId = transactionId
1872 
    args.write(self._oprot)
1873 
    self._oprot.writeMessageEnd()
1874 
    self._oprot.trans.flush()
1875 
 
1398 varun.gupt 1876 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1878 
    if mtype == TMessageType.EXCEPTION:
1879 
      x = TApplicationException()
1880 
      x.read(self._iprot)
1881 
      self._iprot.readMessageEnd()
1882 
      raise x
1398 varun.gupt 1883 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1884 
    result.read(self._iprot)
1885 
    self._iprot.readMessageEnd()
3431 rajveer 1886 
    if result.success is not None:
1382 varun.gupt 1887 
      return result.success
3431 rajveer 1888 
    if result.ex is not None:
1382 varun.gupt 1889 
      raise result.ex
1398 varun.gupt 1890 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1891 
 
4801 anupam.sin 1892 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1893 
    """
1894 
    Parameters:
4801 anupam.sin 1895 
     - statuses
483 rajveer 1896 
     - from_date
1897 
     - to_date
1898 
     - warehouse_id
94 ashish 1899 
    """
4801 anupam.sin 1900 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1901 
    return self.recv_getAllOrders()
94 ashish 1902 
 
4801 anupam.sin 1903 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1904 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1905 
    args = getAllOrders_args()
4801 anupam.sin 1906 
    args.statuses = statuses
483 rajveer 1907 
    args.from_date = from_date
1908 
    args.to_date = to_date
1909 
    args.warehouse_id = warehouse_id
94 ashish 1910 
    args.write(self._oprot)
1911 
    self._oprot.writeMessageEnd()
1912 
    self._oprot.trans.flush()
1913 
 
483 rajveer 1914 
  def recv_getAllOrders(self, ):
94 ashish 1915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1916 
    if mtype == TMessageType.EXCEPTION:
1917 
      x = TApplicationException()
1918 
      x.read(self._iprot)
1919 
      self._iprot.readMessageEnd()
1920 
      raise x
483 rajveer 1921 
    result = getAllOrders_result()
94 ashish 1922 
    result.read(self._iprot)
1923 
    self._iprot.readMessageEnd()
3431 rajveer 1924 
    if result.success is not None:
94 ashish 1925 
      return result.success
3431 rajveer 1926 
    if result.ex is not None:
94 ashish 1927 
      raise result.ex
483 rajveer 1928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1929 
 
4133 chandransh 1930 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1931 
    """
1932 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1933 
    Pass the status as null and the limit as 0 to ignore them.
1934 
 
1935 
    Parameters:
1936 
     - statuses
1937 
     - offset
1938 
     - limit
1939 
     - warehouse_id
1940 
    """
1941 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1942 
    return self.recv_getOrdersInBatch()
1943 
 
1944 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1945 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1946 
    args = getOrdersInBatch_args()
1947 
    args.statuses = statuses
1948 
    args.offset = offset
1949 
    args.limit = limit
1950 
    args.warehouse_id = warehouse_id
1951 
    args.write(self._oprot)
1952 
    self._oprot.writeMessageEnd()
1953 
    self._oprot.trans.flush()
1954 
 
1955 
  def recv_getOrdersInBatch(self, ):
1956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1957 
    if mtype == TMessageType.EXCEPTION:
1958 
      x = TApplicationException()
1959 
      x.read(self._iprot)
1960 
      self._iprot.readMessageEnd()
1961 
      raise x
1962 
    result = getOrdersInBatch_result()
1963 
    result.read(self._iprot)
1964 
    self._iprot.readMessageEnd()
1965 
    if result.success is not None:
1966 
      return result.success
1967 
    if result.ex is not None:
1968 
      raise result.ex
1969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1970 
 
1971 
  def getOrderCount(self, statuses, warehouseId):
1972 
    """
1973 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1974 
 
1975 
    Parameters:
1976 
     - statuses
1977 
     - warehouseId
1978 
    """
1979 
    self.send_getOrderCount(statuses, warehouseId)
1980 
    return self.recv_getOrderCount()
1981 
 
1982 
  def send_getOrderCount(self, statuses, warehouseId):
1983 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1984 
    args = getOrderCount_args()
1985 
    args.statuses = statuses
1986 
    args.warehouseId = warehouseId
1987 
    args.write(self._oprot)
1988 
    self._oprot.writeMessageEnd()
1989 
    self._oprot.trans.flush()
1990 
 
1991 
  def recv_getOrderCount(self, ):
1992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1993 
    if mtype == TMessageType.EXCEPTION:
1994 
      x = TApplicationException()
1995 
      x.read(self._iprot)
1996 
      self._iprot.readMessageEnd()
1997 
      raise x
1998 
    result = getOrderCount_result()
1999 
    result.read(self._iprot)
2000 
    self._iprot.readMessageEnd()
2001 
    if result.success is not None:
2002 
      return result.success
2003 
    if result.ex is not None:
2004 
      raise result.ex
2005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
2006 
 
999 varun.gupt 2007 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
2008 
    """
1132 chandransh 2009 
    Returns orders within a range of their billing dates
3431 rajveer 2010 
 
999 varun.gupt 2011 
    Parameters:
2012 
     - status
2013 
     - start_billing_date
2014 
     - end_billing_date
2015 
     - warehouse_id
2016 
    """
2017 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
2018 
    return self.recv_getOrdersByBillingDate()
2019 
 
2020 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
2021 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
2022 
    args = getOrdersByBillingDate_args()
2023 
    args.status = status
2024 
    args.start_billing_date = start_billing_date
2025 
    args.end_billing_date = end_billing_date
2026 
    args.warehouse_id = warehouse_id
2027 
    args.write(self._oprot)
2028 
    self._oprot.writeMessageEnd()
2029 
    self._oprot.trans.flush()
2030 
 
2031 
  def recv_getOrdersByBillingDate(self, ):
2032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2033 
    if mtype == TMessageType.EXCEPTION:
2034 
      x = TApplicationException()
2035 
      x.read(self._iprot)
2036 
      self._iprot.readMessageEnd()
2037 
      raise x
2038 
    result = getOrdersByBillingDate_result()
2039 
    result.read(self._iprot)
2040 
    self._iprot.readMessageEnd()
3431 rajveer 2041 
    if result.success is not None:
999 varun.gupt 2042 
      return result.success
3431 rajveer 2043 
    if result.ex is not None:
999 varun.gupt 2044 
      raise result.ex
2045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
2046 
 
3451 chandransh 2047 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2048 
    """
2049 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 2050 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
2051 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 2052 
 
3427 chandransh 2053 
    Parameters:
2054 
     - fromShippingDate
2055 
     - toShippingDate
2056 
     - providerId
2057 
     - warehouseId
3451 chandransh 2058 
     - cod
3427 chandransh 2059 
    """
3451 chandransh 2060 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 2061 
    return self.recv_getOrdersByShippingDate()
2062 
 
3451 chandransh 2063 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2064 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
2065 
    args = getOrdersByShippingDate_args()
2066 
    args.fromShippingDate = fromShippingDate
2067 
    args.toShippingDate = toShippingDate
2068 
    args.providerId = providerId
2069 
    args.warehouseId = warehouseId
3451 chandransh 2070 
    args.cod = cod
3427 chandransh 2071 
    args.write(self._oprot)
2072 
    self._oprot.writeMessageEnd()
2073 
    self._oprot.trans.flush()
2074 
 
2075 
  def recv_getOrdersByShippingDate(self, ):
2076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2077 
    if mtype == TMessageType.EXCEPTION:
2078 
      x = TApplicationException()
2079 
      x.read(self._iprot)
2080 
      self._iprot.readMessageEnd()
2081 
      raise x
2082 
    result = getOrdersByShippingDate_result()
2083 
    result.read(self._iprot)
2084 
    self._iprot.readMessageEnd()
3431 rajveer 2085 
    if result.success is not None:
3427 chandransh 2086 
      return result.success
3431 rajveer 2087 
    if result.ex is not None:
3427 chandransh 2088 
      raise result.ex
2089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
2090 
 
1382 varun.gupt 2091 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
2092 
    """
2093 
    Returns order ids for orders which can be returned
3431 rajveer 2094 
 
1382 varun.gupt 2095 
    Parameters:
2096 
     - customer_id
2097 
     - limit
2098 
    """
2099 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2100 
    return self.recv_getReturnableOrdersForCustomer()
2101 
 
2102 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2103 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2104 
    args = getReturnableOrdersForCustomer_args()
2105 
    args.customer_id = customer_id
2106 
    args.limit = limit
2107 
    args.write(self._oprot)
2108 
    self._oprot.writeMessageEnd()
2109 
    self._oprot.trans.flush()
2110 
 
2111 
  def recv_getReturnableOrdersForCustomer(self, ):
2112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2113 
    if mtype == TMessageType.EXCEPTION:
2114 
      x = TApplicationException()
2115 
      x.read(self._iprot)
2116 
      self._iprot.readMessageEnd()
2117 
      raise x
2118 
    result = getReturnableOrdersForCustomer_result()
2119 
    result.read(self._iprot)
2120 
    self._iprot.readMessageEnd()
3431 rajveer 2121 
    if result.success is not None:
1382 varun.gupt 2122 
      return result.success
3431 rajveer 2123 
    if result.ex is not None:
1382 varun.gupt 2124 
      raise result.ex
2125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2126 
 
2127 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2128 
    """
2129 
    Returns order ids for orders which can be cancelled
3431 rajveer 2130 
 
1382 varun.gupt 2131 
    Parameters:
2132 
     - customer_id
2133 
     - limit
2134 
    """
2135 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2136 
    return self.recv_getCancellableOrdersForCustomer()
2137 
 
2138 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2139 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2140 
    args = getCancellableOrdersForCustomer_args()
2141 
    args.customer_id = customer_id
2142 
    args.limit = limit
2143 
    args.write(self._oprot)
2144 
    self._oprot.writeMessageEnd()
2145 
    self._oprot.trans.flush()
2146 
 
2147 
  def recv_getCancellableOrdersForCustomer(self, ):
2148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2149 
    if mtype == TMessageType.EXCEPTION:
2150 
      x = TApplicationException()
2151 
      x.read(self._iprot)
2152 
      self._iprot.readMessageEnd()
2153 
      raise x
2154 
    result = getCancellableOrdersForCustomer_result()
2155 
    result.read(self._iprot)
2156 
    self._iprot.readMessageEnd()
3431 rajveer 2157 
    if result.success is not None:
1382 varun.gupt 2158 
      return result.success
3431 rajveer 2159 
    if result.ex is not None:
1382 varun.gupt 2160 
      raise result.ex
2161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2162 
 
483 rajveer 2163 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2164 
    """
2165 
    Parameters:
483 rajveer 2166 
     - orderId
2167 
     - status
2168 
     - description
94 ashish 2169 
    """
483 rajveer 2170 
    self.send_changeOrderStatus(orderId, status, description)
2171 
    return self.recv_changeOrderStatus()
94 ashish 2172 
 
483 rajveer 2173 
  def send_changeOrderStatus(self, orderId, status, description):
2174 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2175 
    args = changeOrderStatus_args()
2176 
    args.orderId = orderId
2177 
    args.status = status
2178 
    args.description = description
94 ashish 2179 
    args.write(self._oprot)
2180 
    self._oprot.writeMessageEnd()
2181 
    self._oprot.trans.flush()
2182 
 
483 rajveer 2183 
  def recv_changeOrderStatus(self, ):
94 ashish 2184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2185 
    if mtype == TMessageType.EXCEPTION:
2186 
      x = TApplicationException()
2187 
      x.read(self._iprot)
2188 
      self._iprot.readMessageEnd()
2189 
      raise x
483 rajveer 2190 
    result = changeOrderStatus_result()
94 ashish 2191 
    result.read(self._iprot)
2192 
    self._iprot.readMessageEnd()
3431 rajveer 2193 
    if result.success is not None:
94 ashish 2194 
      return result.success
3431 rajveer 2195 
    if result.ex is not None:
94 ashish 2196 
      raise result.ex
483 rajveer 2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2198 
 
1528 ankur.sing 2199 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2200 
    """
1528 ankur.sing 2201 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2202 
    only user who owns the transaction can view its order details.
3431 rajveer 2203 
 
94 ashish 2204 
    Parameters:
2205 
     - transactionId
1528 ankur.sing 2206 
     - customerId
94 ashish 2207 
    """
1528 ankur.sing 2208 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2209 
    return self.recv_getOrdersForTransaction()
94 ashish 2210 
 
1528 ankur.sing 2211 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2212 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2213 
    args = getOrdersForTransaction_args()
94 ashish 2214 
    args.transactionId = transactionId
1528 ankur.sing 2215 
    args.customerId = customerId
94 ashish 2216 
    args.write(self._oprot)
2217 
    self._oprot.writeMessageEnd()
2218 
    self._oprot.trans.flush()
2219 
 
483 rajveer 2220 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2222 
    if mtype == TMessageType.EXCEPTION:
2223 
      x = TApplicationException()
2224 
      x.read(self._iprot)
2225 
      self._iprot.readMessageEnd()
2226 
      raise x
483 rajveer 2227 
    result = getOrdersForTransaction_result()
94 ashish 2228 
    result.read(self._iprot)
2229 
    self._iprot.readMessageEnd()
3431 rajveer 2230 
    if result.success is not None:
94 ashish 2231 
      return result.success
3431 rajveer 2232 
    if result.ex is not None:
94 ashish 2233 
      raise result.ex
483 rajveer 2234 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2235 
 
3014 chandransh 2236 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2237 
    """
3014 chandransh 2238 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2239 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2240 
 
94 ashish 2241 
    Parameters:
483 rajveer 2242 
     - customerId
2243 
     - from_date
2244 
     - to_date
3014 chandransh 2245 
     - statuses
94 ashish 2246 
    """
3014 chandransh 2247 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2248 
    return self.recv_getOrdersForCustomer()
94 ashish 2249 
 
3014 chandransh 2250 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2251 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2252 
    args = getOrdersForCustomer_args()
2253 
    args.customerId = customerId
2254 
    args.from_date = from_date
2255 
    args.to_date = to_date
3014 chandransh 2256 
    args.statuses = statuses
94 ashish 2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
483 rajveer 2261 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2263 
    if mtype == TMessageType.EXCEPTION:
2264 
      x = TApplicationException()
2265 
      x.read(self._iprot)
2266 
      self._iprot.readMessageEnd()
2267 
      raise x
483 rajveer 2268 
    result = getOrdersForCustomer_result()
94 ashish 2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
3431 rajveer 2271 
    if result.success is not None:
94 ashish 2272 
      return result.success
3431 rajveer 2273 
    if result.ex is not None:
94 ashish 2274 
      raise result.ex
483 rajveer 2275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2276 
 
483 rajveer 2277 
  def createOrder(self, order):
94 ashish 2278 
    """
2279 
    Parameters:
483 rajveer 2280 
     - order
94 ashish 2281 
    """
483 rajveer 2282 
    self.send_createOrder(order)
2283 
    return self.recv_createOrder()
94 ashish 2284 
 
483 rajveer 2285 
  def send_createOrder(self, order):
2286 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2287 
    args = createOrder_args()
2288 
    args.order = order
94 ashish 2289 
    args.write(self._oprot)
2290 
    self._oprot.writeMessageEnd()
2291 
    self._oprot.trans.flush()
2292 
 
483 rajveer 2293 
  def recv_createOrder(self, ):
94 ashish 2294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2295 
    if mtype == TMessageType.EXCEPTION:
2296 
      x = TApplicationException()
2297 
      x.read(self._iprot)
2298 
      self._iprot.readMessageEnd()
2299 
      raise x
483 rajveer 2300 
    result = createOrder_result()
94 ashish 2301 
    result.read(self._iprot)
2302 
    self._iprot.readMessageEnd()
3431 rajveer 2303 
    if result.success is not None:
94 ashish 2304 
      return result.success
3431 rajveer 2305 
    if result.ex is not None:
94 ashish 2306 
      raise result.ex
483 rajveer 2307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2308 
 
483 rajveer 2309 
  def getOrder(self, id):
94 ashish 2310 
    """
2311 
    Parameters:
483 rajveer 2312 
     - id
94 ashish 2313 
    """
483 rajveer 2314 
    self.send_getOrder(id)
2315 
    return self.recv_getOrder()
94 ashish 2316 
 
483 rajveer 2317 
  def send_getOrder(self, id):
2318 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2319 
    args = getOrder_args()
2320 
    args.id = id
94 ashish 2321 
    args.write(self._oprot)
2322 
    self._oprot.writeMessageEnd()
2323 
    self._oprot.trans.flush()
2324 
 
483 rajveer 2325 
  def recv_getOrder(self, ):
94 ashish 2326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2327 
    if mtype == TMessageType.EXCEPTION:
2328 
      x = TApplicationException()
2329 
      x.read(self._iprot)
2330 
      self._iprot.readMessageEnd()
2331 
      raise x
483 rajveer 2332 
    result = getOrder_result()
94 ashish 2333 
    result.read(self._iprot)
2334 
    self._iprot.readMessageEnd()
3431 rajveer 2335 
    if result.success is not None:
94 ashish 2336 
      return result.success
3431 rajveer 2337 
    if result.ex is not None:
94 ashish 2338 
      raise result.ex
483 rajveer 2339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2340 
 
483 rajveer 2341 
  def getLineItemsForOrder(self, orderId):
94 ashish 2342 
    """
2343 
    Parameters:
483 rajveer 2344 
     - orderId
94 ashish 2345 
    """
483 rajveer 2346 
    self.send_getLineItemsForOrder(orderId)
2347 
    return self.recv_getLineItemsForOrder()
94 ashish 2348 
 
483 rajveer 2349 
  def send_getLineItemsForOrder(self, orderId):
2350 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2351 
    args = getLineItemsForOrder_args()
2352 
    args.orderId = orderId
94 ashish 2353 
    args.write(self._oprot)
2354 
    self._oprot.writeMessageEnd()
2355 
    self._oprot.trans.flush()
2356 
 
483 rajveer 2357 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2359 
    if mtype == TMessageType.EXCEPTION:
2360 
      x = TApplicationException()
2361 
      x.read(self._iprot)
2362 
      self._iprot.readMessageEnd()
2363 
      raise x
483 rajveer 2364 
    result = getLineItemsForOrder_result()
94 ashish 2365 
    result.read(self._iprot)
2366 
    self._iprot.readMessageEnd()
3431 rajveer 2367 
    if result.success is not None:
94 ashish 2368 
      return result.success
3431 rajveer 2369 
    if result.ex is not None:
94 ashish 2370 
      raise result.ex
483 rajveer 2371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2372 
 
4999 phani.kuma 2373 
  def getOrderList(self, order_ids):
2374 
    """
2375 
    Parameters:
2376 
     - order_ids
2377 
    """
2378 
    self.send_getOrderList(order_ids)
2379 
    return self.recv_getOrderList()
2380 
 
2381 
  def send_getOrderList(self, order_ids):
2382 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2383 
    args = getOrderList_args()
2384 
    args.order_ids = order_ids
2385 
    args.write(self._oprot)
2386 
    self._oprot.writeMessageEnd()
2387 
    self._oprot.trans.flush()
2388 
 
2389 
  def recv_getOrderList(self, ):
2390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2391 
    if mtype == TMessageType.EXCEPTION:
2392 
      x = TApplicationException()
2393 
      x.read(self._iprot)
2394 
      self._iprot.readMessageEnd()
2395 
      raise x
2396 
    result = getOrderList_result()
2397 
    result.read(self._iprot)
2398 
    self._iprot.readMessageEnd()
2399 
    if result.success is not None:
2400 
      return result.success
2401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2402 
 
5386 phani.kuma 2403 
  def getOrderListForVendor(self, order_ids, vendorId):
2404 
    """
2405 
    Parameters:
2406 
     - order_ids
2407 
     - vendorId
2408 
    """
2409 
    self.send_getOrderListForVendor(order_ids, vendorId)
2410 
    return self.recv_getOrderListForVendor()
2411 
 
2412 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2413 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2414 
    args = getOrderListForVendor_args()
2415 
    args.order_ids = order_ids
2416 
    args.vendorId = vendorId
2417 
    args.write(self._oprot)
2418 
    self._oprot.writeMessageEnd()
2419 
    self._oprot.trans.flush()
2420 
 
2421 
  def recv_getOrderListForVendor(self, ):
2422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2423 
    if mtype == TMessageType.EXCEPTION:
2424 
      x = TApplicationException()
2425 
      x.read(self._iprot)
2426 
      self._iprot.readMessageEnd()
2427 
      raise x
2428 
    result = getOrderListForVendor_result()
2429 
    result.read(self._iprot)
2430 
    self._iprot.readMessageEnd()
2431 
    if result.success is not None:
2432 
      return result.success
2433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2434 
 
1528 ankur.sing 2435 
  def getOrderForCustomer(self, orderId, customerId):
2436 
    """
2437 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2438 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2439 
 
1528 ankur.sing 2440 
    Parameters:
2441 
     - orderId
2442 
     - customerId
2443 
    """
2444 
    self.send_getOrderForCustomer(orderId, customerId)
2445 
    return self.recv_getOrderForCustomer()
2446 
 
2447 
  def send_getOrderForCustomer(self, orderId, customerId):
2448 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2449 
    args = getOrderForCustomer_args()
2450 
    args.orderId = orderId
2451 
    args.customerId = customerId
2452 
    args.write(self._oprot)
2453 
    self._oprot.writeMessageEnd()
2454 
    self._oprot.trans.flush()
2455 
 
2456 
  def recv_getOrderForCustomer(self, ):
2457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2458 
    if mtype == TMessageType.EXCEPTION:
2459 
      x = TApplicationException()
2460 
      x.read(self._iprot)
2461 
      self._iprot.readMessageEnd()
2462 
      raise x
2463 
    result = getOrderForCustomer_result()
2464 
    result.read(self._iprot)
2465 
    self._iprot.readMessageEnd()
3431 rajveer 2466 
    if result.success is not None:
1528 ankur.sing 2467 
      return result.success
3431 rajveer 2468 
    if result.ex is not None:
1528 ankur.sing 2469 
      raise result.ex
2470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2471 
 
4444 rajveer 2472 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2473 
    """
2474 
    Parameters:
4394 rajveer 2475 
     - type
4444 rajveer 2476 
     - warehouseId
4394 rajveer 2477 
     - status
2478 
     - timestamp
3064 chandransh 2479 
    """
4444 rajveer 2480 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2481 
    return self.recv_getAlerts()
2482 
 
4444 rajveer 2483 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2484 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2485 
    args = getAlerts_args()
4394 rajveer 2486 
    args.type = type
4444 rajveer 2487 
    args.warehouseId = warehouseId
4394 rajveer 2488 
    args.status = status
2489 
    args.timestamp = timestamp
3064 chandransh 2490 
    args.write(self._oprot)
2491 
    self._oprot.writeMessageEnd()
2492 
    self._oprot.trans.flush()
2493 
 
2494 
  def recv_getAlerts(self, ):
2495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2496 
    if mtype == TMessageType.EXCEPTION:
2497 
      x = TApplicationException()
2498 
      x.read(self._iprot)
2499 
      self._iprot.readMessageEnd()
2500 
      raise x
2501 
    result = getAlerts_result()
2502 
    result.read(self._iprot)
2503 
    self._iprot.readMessageEnd()
3431 rajveer 2504 
    if result.success is not None:
3064 chandransh 2505 
      return result.success
2506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2507 
 
4444 rajveer 2508 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2509 
    """
2510 
    Parameters:
2511 
     - type
4444 rajveer 2512 
     - warehouseId
4394 rajveer 2513 
     - description
3064 chandransh 2514 
    """
4444 rajveer 2515 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2516 
    self.recv_addAlert()
3064 chandransh 2517 
 
4444 rajveer 2518 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2519 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2520 
    args = addAlert_args()
3064 chandransh 2521 
    args.type = type
4444 rajveer 2522 
    args.warehouseId = warehouseId
4394 rajveer 2523 
    args.description = description
3064 chandransh 2524 
    args.write(self._oprot)
2525 
    self._oprot.writeMessageEnd()
2526 
    self._oprot.trans.flush()
2527 
 
4394 rajveer 2528 
  def recv_addAlert(self, ):
3064 chandransh 2529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2530 
    if mtype == TMessageType.EXCEPTION:
2531 
      x = TApplicationException()
2532 
      x.read(self._iprot)
2533 
      self._iprot.readMessageEnd()
2534 
      raise x
4394 rajveer 2535 
    result = addAlert_result()
3064 chandransh 2536 
    result.read(self._iprot)
2537 
    self._iprot.readMessageEnd()
2538 
    return
2539 
 
4444 rajveer 2540 
  def markAlertsAsSeen(self, warehouseId):
2541 
    """
2542 
    Parameters:
2543 
     - warehouseId
2544 
    """
2545 
    self.send_markAlertsAsSeen(warehouseId)
2546 
    self.recv_markAlertsAsSeen()
2547 
 
2548 
  def send_markAlertsAsSeen(self, warehouseId):
2549 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2550 
    args = markAlertsAsSeen_args()
2551 
    args.warehouseId = warehouseId
2552 
    args.write(self._oprot)
2553 
    self._oprot.writeMessageEnd()
2554 
    self._oprot.trans.flush()
2555 
 
2556 
  def recv_markAlertsAsSeen(self, ):
2557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2558 
    if mtype == TMessageType.EXCEPTION:
2559 
      x = TApplicationException()
2560 
      x.read(self._iprot)
2561 
      self._iprot.readMessageEnd()
2562 
      raise x
2563 
    result = markAlertsAsSeen_result()
2564 
    result.read(self._iprot)
2565 
    self._iprot.readMessageEnd()
2566 
    return
2567 
 
3064 chandransh 2568 
  def getValidOrderCount(self, ):
2569 
    """
2570 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2571 
    """
2572 
    self.send_getValidOrderCount()
2573 
    return self.recv_getValidOrderCount()
2574 
 
2575 
  def send_getValidOrderCount(self, ):
2576 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2577 
    args = getValidOrderCount_args()
2578 
    args.write(self._oprot)
2579 
    self._oprot.writeMessageEnd()
2580 
    self._oprot.trans.flush()
2581 
 
2582 
  def recv_getValidOrderCount(self, ):
2583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2584 
    if mtype == TMessageType.EXCEPTION:
2585 
      x = TApplicationException()
2586 
      x.read(self._iprot)
2587 
      self._iprot.readMessageEnd()
2588 
      raise x
2589 
    result = getValidOrderCount_result()
2590 
    result.read(self._iprot)
2591 
    self._iprot.readMessageEnd()
3431 rajveer 2592 
    if result.success is not None:
3064 chandransh 2593 
      return result.success
2594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2595 
 
2596 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2597 
    """
2598 
    Returns the number of distinct customers who have done successful transactions
2599 
    """
2600 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2601 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2602 
 
2603 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2604 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2605 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2606 
    args.write(self._oprot)
2607 
    self._oprot.writeMessageEnd()
2608 
    self._oprot.trans.flush()
2609 
 
2610 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2612 
    if mtype == TMessageType.EXCEPTION:
2613 
      x = TApplicationException()
2614 
      x.read(self._iprot)
2615 
      self._iprot.readMessageEnd()
2616 
      raise x
2617 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2618 
    result.read(self._iprot)
2619 
    self._iprot.readMessageEnd()
3431 rajveer 2620 
    if result.success is not None:
3064 chandransh 2621 
      return result.success
2622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2623 
 
2624 
  def getValidOrdersAmountRange(self, ):
2625 
    """
2626 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2627 
    List contains two values, first minimum amount and second maximum amount.
2628 
    """
2629 
    self.send_getValidOrdersAmountRange()
2630 
    return self.recv_getValidOrdersAmountRange()
2631 
 
2632 
  def send_getValidOrdersAmountRange(self, ):
2633 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2634 
    args = getValidOrdersAmountRange_args()
2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
2639 
  def recv_getValidOrdersAmountRange(self, ):
2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
2646 
    result = getValidOrdersAmountRange_result()
2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
3431 rajveer 2649 
    if result.success is not None:
3064 chandransh 2650 
      return result.success
2651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2652 
 
5874 rajveer 2653 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2654 
    """
2655 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2656 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2657 
 
3064 chandransh 2658 
    Parameters:
2659 
     - limit
5874 rajveer 2660 
     - onlyStore
3064 chandransh 2661 
    """
5874 rajveer 2662 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2663 
    return self.recv_getValidOrders()
2664 
 
5874 rajveer 2665 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2666 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2667 
    args = getValidOrders_args()
2668 
    args.limit = limit
5874 rajveer 2669 
    args.onlyStore = onlyStore
3064 chandransh 2670 
    args.write(self._oprot)
2671 
    self._oprot.writeMessageEnd()
2672 
    self._oprot.trans.flush()
2673 
 
2674 
  def recv_getValidOrders(self, ):
2675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2676 
    if mtype == TMessageType.EXCEPTION:
2677 
      x = TApplicationException()
2678 
      x.read(self._iprot)
2679 
      self._iprot.readMessageEnd()
2680 
      raise x
2681 
    result = getValidOrders_result()
2682 
    result.read(self._iprot)
2683 
    self._iprot.readMessageEnd()
3431 rajveer 2684 
    if result.success is not None:
3064 chandransh 2685 
      return result.success
2686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2687 
 
1220 chandransh 2688 
  def batchOrders(self, warehouseId):
2689 
    """
2690 
    Create a batch of all the pending orders for the given warehouse.
2691 
    The returned list is orderd by created_timestamp.
2692 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2693 
 
1220 chandransh 2694 
    Parameters:
2695 
     - warehouseId
2696 
    """
2697 
    self.send_batchOrders(warehouseId)
2698 
    return self.recv_batchOrders()
2699 
 
2700 
  def send_batchOrders(self, warehouseId):
2701 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2702 
    args = batchOrders_args()
2703 
    args.warehouseId = warehouseId
2704 
    args.write(self._oprot)
2705 
    self._oprot.writeMessageEnd()
2706 
    self._oprot.trans.flush()
2707 
 
2708 
  def recv_batchOrders(self, ):
2709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2710 
    if mtype == TMessageType.EXCEPTION:
2711 
      x = TApplicationException()
2712 
      x.read(self._iprot)
2713 
      self._iprot.readMessageEnd()
2714 
      raise x
2715 
    result = batchOrders_result()
2716 
    result.read(self._iprot)
2717 
    self._iprot.readMessageEnd()
3431 rajveer 2718 
    if result.success is not None:
1220 chandransh 2719 
      return result.success
3431 rajveer 2720 
    if result.ex is not None:
1220 chandransh 2721 
      raise result.ex
2722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2723 
 
1208 chandransh 2724 
  def markOrderAsOutOfStock(self, orderId):
2725 
    """
2726 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2727 
 
1208 chandransh 2728 
    Parameters:
2729 
     - orderId
2730 
    """
2731 
    self.send_markOrderAsOutOfStock(orderId)
2732 
    return self.recv_markOrderAsOutOfStock()
2733 
 
2734 
  def send_markOrderAsOutOfStock(self, orderId):
2735 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2736 
    args = markOrderAsOutOfStock_args()
2737 
    args.orderId = orderId
2738 
    args.write(self._oprot)
2739 
    self._oprot.writeMessageEnd()
2740 
    self._oprot.trans.flush()
2741 
 
2742 
  def recv_markOrderAsOutOfStock(self, ):
2743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2744 
    if mtype == TMessageType.EXCEPTION:
2745 
      x = TApplicationException()
2746 
      x.read(self._iprot)
2747 
      self._iprot.readMessageEnd()
2748 
      raise x
2749 
    result = markOrderAsOutOfStock_result()
2750 
    result.read(self._iprot)
2751 
    self._iprot.readMessageEnd()
3431 rajveer 2752 
    if result.success is not None:
1208 chandransh 2753 
      return result.success
3431 rajveer 2754 
    if result.ex is not None:
1208 chandransh 2755 
      raise result.ex
2756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2757 
 
3064 chandransh 2758 
  def verifyOrder(self, orderId):
759 chandransh 2759 
    """
3064 chandransh 2760 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2761 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2762 
    used for all other orders as well.
2763 
    Throws an exception if no such order exists.
3431 rajveer 2764 
 
759 chandransh 2765 
    Parameters:
3064 chandransh 2766 
     - orderId
759 chandransh 2767 
    """
3064 chandransh 2768 
    self.send_verifyOrder(orderId)
2769 
    return self.recv_verifyOrder()
759 chandransh 2770 
 
3064 chandransh 2771 
  def send_verifyOrder(self, orderId):
2772 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2773 
    args = verifyOrder_args()
2774 
    args.orderId = orderId
759 chandransh 2775 
    args.write(self._oprot)
2776 
    self._oprot.writeMessageEnd()
2777 
    self._oprot.trans.flush()
2778 
 
3064 chandransh 2779 
  def recv_verifyOrder(self, ):
759 chandransh 2780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2781 
    if mtype == TMessageType.EXCEPTION:
2782 
      x = TApplicationException()
2783 
      x.read(self._iprot)
2784 
      self._iprot.readMessageEnd()
2785 
      raise x
3064 chandransh 2786 
    result = verifyOrder_result()
759 chandransh 2787 
    result.read(self._iprot)
2788 
    self._iprot.readMessageEnd()
3431 rajveer 2789 
    if result.success is not None:
759 chandransh 2790 
      return result.success
3431 rajveer 2791 
    if result.ex is not None:
759 chandransh 2792 
      raise result.ex
3064 chandransh 2793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2794 
 
3064 chandransh 2795 
  def acceptOrder(self, orderId):
1113 chandransh 2796 
    """
3064 chandransh 2797 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2798 
    given order is not a COD order, it also captures the payment if the same has
2799 
    not been captured.
2800 
    Throws an exception if no such order exists.
3431 rajveer 2801 
 
1113 chandransh 2802 
    Parameters:
3064 chandransh 2803 
     - orderId
1113 chandransh 2804 
    """
3064 chandransh 2805 
    self.send_acceptOrder(orderId)
2806 
    return self.recv_acceptOrder()
1113 chandransh 2807 
 
3064 chandransh 2808 
  def send_acceptOrder(self, orderId):
2809 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2810 
    args = acceptOrder_args()
2811 
    args.orderId = orderId
1113 chandransh 2812 
    args.write(self._oprot)
2813 
    self._oprot.writeMessageEnd()
2814 
    self._oprot.trans.flush()
2815 
 
3064 chandransh 2816 
  def recv_acceptOrder(self, ):
1113 chandransh 2817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2818 
    if mtype == TMessageType.EXCEPTION:
2819 
      x = TApplicationException()
2820 
      x.read(self._iprot)
2821 
      self._iprot.readMessageEnd()
2822 
      raise x
3064 chandransh 2823 
    result = acceptOrder_result()
1113 chandransh 2824 
    result.read(self._iprot)
2825 
    self._iprot.readMessageEnd()
3431 rajveer 2826 
    if result.success is not None:
1113 chandransh 2827 
      return result.success
3431 rajveer 2828 
    if result.ex is not None:
1113 chandransh 2829 
      raise result.ex
3064 chandransh 2830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2831 
 
7190 amar.kumar 2832 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2833 
    """
3064 chandransh 2834 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2835 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2836 
    the IMEI no. if a -1 is supplied.
2837 
    Also, it generates an invoice number for the order, marks the order as
2838 
    BILLED and sets the billing timestamp.
2839 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2840 
 
1135 chandransh 2841 
    Parameters:
3064 chandransh 2842 
     - orderId
2843 
     - invoice_number
4658 mandeep.dh 2844 
     - serialNumber
4283 anupam.sin 2845 
     - itemNumber
7190 amar.kumar 2846 
     - freebieWarehouseId
3064 chandransh 2847 
     - billed_by
4264 rajveer 2848 
     - jacketNumber
4283 anupam.sin 2849 
     - billingType
5110 mandeep.dh 2850 
     - fulfilmentWarehouseId
4763 rajveer 2851 
     - authorize
1135 chandransh 2852 
    """
7190 amar.kumar 2853 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2854 
    return self.recv_addBillingDetails()
1135 chandransh 2855 
 
7190 amar.kumar 2856 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2857 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2858 
    args = addBillingDetails_args()
2859 
    args.orderId = orderId
2860 
    args.invoice_number = invoice_number
4658 mandeep.dh 2861 
    args.serialNumber = serialNumber
4283 anupam.sin 2862 
    args.itemNumber = itemNumber
7190 amar.kumar 2863 
    args.freebieWarehouseId = freebieWarehouseId
3064 chandransh 2864 
    args.billed_by = billed_by
4264 rajveer 2865 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2866 
    args.billingType = billingType
5110 mandeep.dh 2867 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2868 
    args.authorize = authorize
1135 chandransh 2869 
    args.write(self._oprot)
2870 
    self._oprot.writeMessageEnd()
2871 
    self._oprot.trans.flush()
2872 
 
3064 chandransh 2873 
  def recv_addBillingDetails(self, ):
1135 chandransh 2874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2875 
    if mtype == TMessageType.EXCEPTION:
2876 
      x = TApplicationException()
2877 
      x.read(self._iprot)
2878 
      self._iprot.readMessageEnd()
2879 
      raise x
3064 chandransh 2880 
    result = addBillingDetails_result()
1135 chandransh 2881 
    result.read(self._iprot)
2882 
    self._iprot.readMessageEnd()
3431 rajveer 2883 
    if result.success is not None:
3064 chandransh 2884 
      return result.success
3431 rajveer 2885 
    if result.ex is not None:
1135 chandransh 2886 
      raise result.ex
3064 chandransh 2887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2888 
 
6756 amar.kumar 2889 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2890 
    """
2891 
    Add the invoice number to the order.
2892 
 
2893 
    Parameters:
2894 
     - orderId
2895 
     - invoiceNumber
4763 rajveer 2896 
     - color
6756 amar.kumar 2897 
     - serialNumber
2898 
     - itemNumber
4579 rajveer 2899 
    """
6756 amar.kumar 2900 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2901 
    self.recv_addInvoiceNumber()
2902 
 
6756 amar.kumar 2903 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2904 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2905 
    args = addInvoiceNumber_args()
2906 
    args.orderId = orderId
2907 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2908 
    args.color = color
6756 amar.kumar 2909 
    args.serialNumber = serialNumber
2910 
    args.itemNumber = itemNumber
4579 rajveer 2911 
    args.write(self._oprot)
2912 
    self._oprot.writeMessageEnd()
2913 
    self._oprot.trans.flush()
2914 
 
2915 
  def recv_addInvoiceNumber(self, ):
2916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2917 
    if mtype == TMessageType.EXCEPTION:
2918 
      x = TApplicationException()
2919 
      x.read(self._iprot)
2920 
      self._iprot.readMessageEnd()
2921 
      raise x
2922 
    result = addInvoiceNumber_result()
2923 
    result.read(self._iprot)
2924 
    self._iprot.readMessageEnd()
2925 
    if result.ex is not None:
2926 
      raise result.ex
2927 
    return
2928 
 
4910 phani.kuma 2929 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2930 
    """
3064 chandransh 2931 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2932 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2933 
 
1408 ankur.sing 2934 
    Parameters:
3064 chandransh 2935 
     - warehouseId
1408 ankur.sing 2936 
     - providerId
3064 chandransh 2937 
     - cod
4910 phani.kuma 2938 
     - orderIds
1408 ankur.sing 2939 
    """
4910 phani.kuma 2940 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2941 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2942 
 
4910 phani.kuma 2943 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2944 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2945 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2946 
    args.warehouseId = warehouseId
1408 ankur.sing 2947 
    args.providerId = providerId
3064 chandransh 2948 
    args.cod = cod
4910 phani.kuma 2949 
    args.orderIds = orderIds
1408 ankur.sing 2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
4910 phani.kuma 2954 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
4910 phani.kuma 2961 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
3431 rajveer 2964 
    if result.success is not None:
1408 ankur.sing 2965 
      return result.success
3431 rajveer 2966 
    if result.ex is not None:
3064 chandransh 2967 
      raise result.ex
4910 phani.kuma 2968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2969 
 
5713 rajveer 2970 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2971 
    """
2972 
    Parameters:
2973 
     - providerId
2974 
     - orderIds
5713 rajveer 2975 
     - awbs
5676 rajveer 2976 
    """
5713 rajveer 2977 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2978 
    return self.recv_markOrdersAsReturnedFromStore()
2979 
 
5713 rajveer 2980 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2981 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2982 
    args = markOrdersAsReturnedFromStore_args()
2983 
    args.providerId = providerId
2984 
    args.orderIds = orderIds
5713 rajveer 2985 
    args.awbs = awbs
5676 rajveer 2986 
    args.write(self._oprot)
2987 
    self._oprot.writeMessageEnd()
2988 
    self._oprot.trans.flush()
2989 
 
2990 
  def recv_markOrdersAsReturnedFromStore(self, ):
2991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2992 
    if mtype == TMessageType.EXCEPTION:
2993 
      x = TApplicationException()
2994 
      x.read(self._iprot)
2995 
      self._iprot.readMessageEnd()
2996 
      raise x
2997 
    result = markOrdersAsReturnedFromStore_result()
2998 
    result.read(self._iprot)
2999 
    self._iprot.readMessageEnd()
3000 
    if result.success is not None:
3001 
      return result.success
3002 
    if result.ex is not None:
3003 
      raise result.ex
3004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
3005 
 
4910 phani.kuma 3006 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 3007 
    """
4910 phani.kuma 3008 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
3009 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 3010 
 
3011 
    Parameters:
3012 
     - providerId
4910 phani.kuma 3013 
     - pickupDetails
4410 rajveer 3014 
    """
4910 phani.kuma 3015 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
3016 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 3017 
 
4910 phani.kuma 3018 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
3019 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3020 
    args = markOrdersAsPickedUp_args()
4410 rajveer 3021 
    args.providerId = providerId
4910 phani.kuma 3022 
    args.pickupDetails = pickupDetails
4410 rajveer 3023 
    args.write(self._oprot)
3024 
    self._oprot.writeMessageEnd()
3025 
    self._oprot.trans.flush()
3026 
 
4910 phani.kuma 3027 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 3028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3029 
    if mtype == TMessageType.EXCEPTION:
3030 
      x = TApplicationException()
3031 
      x.read(self._iprot)
3032 
      self._iprot.readMessageEnd()
3033 
      raise x
4910 phani.kuma 3034 
    result = markOrdersAsPickedUp_result()
4410 rajveer 3035 
    result.read(self._iprot)
3036 
    self._iprot.readMessageEnd()
3037 
    if result.ex is not None:
3038 
      raise result.ex
4910 phani.kuma 3039 
    return
4410 rajveer 3040 
 
4910 phani.kuma 3041 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 3042 
    """
3064 chandransh 3043 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 3044 
 
94 ashish 3045 
    Parameters:
3064 chandransh 3046 
     - providerId
304 ashish 3047 
    """
4910 phani.kuma 3048 
    self.send_getOrdersNotPickedUp(providerId)
3049 
    return self.recv_getOrdersNotPickedUp()
94 ashish 3050 
 
4910 phani.kuma 3051 
  def send_getOrdersNotPickedUp(self, providerId):
3052 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3053 
    args = getOrdersNotPickedUp_args()
3064 chandransh 3054 
    args.providerId = providerId
304 ashish 3055 
    args.write(self._oprot)
3056 
    self._oprot.writeMessageEnd()
3057 
    self._oprot.trans.flush()
3058 
 
4910 phani.kuma 3059 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 3060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3061 
    if mtype == TMessageType.EXCEPTION:
3062 
      x = TApplicationException()
3063 
      x.read(self._iprot)
3064 
      self._iprot.readMessageEnd()
3065 
      raise x
4910 phani.kuma 3066 
    result = getOrdersNotPickedUp_result()
304 ashish 3067 
    result.read(self._iprot)
3068 
    self._iprot.readMessageEnd()
3431 rajveer 3069 
    if result.success is not None:
304 ashish 3070 
      return result.success
4910 phani.kuma 3071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 3072 
 
3064 chandransh 3073 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 3074 
    """
3064 chandransh 3075 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
3076 
    the name of the receiver.
3077 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3078 
 
304 ashish 3079 
    Parameters:
3064 chandransh 3080 
     - providerId
3081 
     - deliveredOrders
304 ashish 3082 
    """
3064 chandransh 3083 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
3084 
    self.recv_markOrdersAsDelivered()
304 ashish 3085 
 
3064 chandransh 3086 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
3087 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
3088 
    args = markOrdersAsDelivered_args()
3089 
    args.providerId = providerId
3090 
    args.deliveredOrders = deliveredOrders
304 ashish 3091 
    args.write(self._oprot)
3092 
    self._oprot.writeMessageEnd()
3093 
    self._oprot.trans.flush()
3094 
 
3064 chandransh 3095 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 3096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3097 
    if mtype == TMessageType.EXCEPTION:
3098 
      x = TApplicationException()
3099 
      x.read(self._iprot)
3100 
      self._iprot.readMessageEnd()
3101 
      raise x
3064 chandransh 3102 
    result = markOrdersAsDelivered_result()
304 ashish 3103 
    result.read(self._iprot)
3104 
    self._iprot.readMessageEnd()
3431 rajveer 3105 
    if result.ex is not None:
3064 chandransh 3106 
      raise result.ex
304 ashish 3107 
    return
3108 
 
4910 phani.kuma 3109 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3110 
    """
4910 phani.kuma 3111 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3112 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3113 
 
3064 chandransh 3114 
    Parameters:
3115 
     - providerId
3116 
     - returnedOrders
1596 ankur.sing 3117 
    """
4910 phani.kuma 3118 
    self.send_markAsRTOrders(providerId, returnedOrders)
3119 
    self.recv_markAsRTOrders()
304 ashish 3120 
 
4910 phani.kuma 3121 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3122 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3123 
    args = markAsRTOrders_args()
3064 chandransh 3124 
    args.providerId = providerId
3125 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3126 
    args.write(self._oprot)
3127 
    self._oprot.writeMessageEnd()
3128 
    self._oprot.trans.flush()
3129 
 
4910 phani.kuma 3130 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3132 
    if mtype == TMessageType.EXCEPTION:
3133 
      x = TApplicationException()
3134 
      x.read(self._iprot)
3135 
      self._iprot.readMessageEnd()
3136 
      raise x
4910 phani.kuma 3137 
    result = markAsRTOrders_result()
1596 ankur.sing 3138 
    result.read(self._iprot)
3139 
    self._iprot.readMessageEnd()
3431 rajveer 3140 
    if result.ex is not None:
3064 chandransh 3141 
      raise result.ex
3142 
    return
1596 ankur.sing 3143 
 
4910 phani.kuma 3144 
  def getRTOrders(self, providerId):
3145 
    """
3146 
    Returns a list of orders that were returned by courier.
3147 
 
3148 
    Parameters:
3149 
     - providerId
3150 
    """
3151 
    self.send_getRTOrders(providerId)
3152 
    return self.recv_getRTOrders()
3153 
 
3154 
  def send_getRTOrders(self, providerId):
3155 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3156 
    args = getRTOrders_args()
3157 
    args.providerId = providerId
3158 
    args.write(self._oprot)
3159 
    self._oprot.writeMessageEnd()
3160 
    self._oprot.trans.flush()
3161 
 
3162 
  def recv_getRTOrders(self, ):
3163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3164 
    if mtype == TMessageType.EXCEPTION:
3165 
      x = TApplicationException()
3166 
      x.read(self._iprot)
3167 
      self._iprot.readMessageEnd()
3168 
      raise x
3169 
    result = getRTOrders_result()
3170 
    result.read(self._iprot)
3171 
    self._iprot.readMessageEnd()
3172 
    if result.success is not None:
3173 
      return result.success
3174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3175 
 
3064 chandransh 3176 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3177 
    """
3064 chandransh 3178 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3179 
 
3064 chandransh 3180 
    Parameters:
3181 
     - providerId
3182 
     - undeliveredOrders
1627 ankur.sing 3183 
    """
3064 chandransh 3184 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3185 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3186 
 
3064 chandransh 3187 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3188 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3189 
    args = updateNonDeliveryReason_args()
3190 
    args.providerId = providerId
3191 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3192 
    args.write(self._oprot)
3193 
    self._oprot.writeMessageEnd()
3194 
    self._oprot.trans.flush()
3195 
 
3064 chandransh 3196 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3198 
    if mtype == TMessageType.EXCEPTION:
3199 
      x = TApplicationException()
3200 
      x.read(self._iprot)
3201 
      self._iprot.readMessageEnd()
3202 
      raise x
3064 chandransh 3203 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3204 
    result.read(self._iprot)
3205 
    self._iprot.readMessageEnd()
4910 phani.kuma 3206 
    if result.ex is not None:
3207 
      raise result.ex
3208 
    return
3209 
 
3210 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3211 
    """
3212 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3213 
 
3214 
    Parameters:
3215 
     - providerId
3216 
    """
3217 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3218 
    return self.recv_getNonDeliveredOrdersbyCourier()
3219 
 
3220 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3221 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3222 
    args = getNonDeliveredOrdersbyCourier_args()
3223 
    args.providerId = providerId
3224 
    args.write(self._oprot)
3225 
    self._oprot.writeMessageEnd()
3226 
    self._oprot.trans.flush()
3227 
 
3228 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3230 
    if mtype == TMessageType.EXCEPTION:
3231 
      x = TApplicationException()
3232 
      x.read(self._iprot)
3233 
      self._iprot.readMessageEnd()
3234 
      raise x
3235 
    result = getNonDeliveredOrdersbyCourier_result()
3236 
    result.read(self._iprot)
3237 
    self._iprot.readMessageEnd()
4581 phani.kuma 3238 
    if result.success is not None:
3239 
      return result.success
4910 phani.kuma 3240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3241 
 
3242 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3243 
    """
3244 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3245 
 
3246 
    Parameters:
3247 
     - providerId
3248 
     - local_connected_orders
3249 
    """
3250 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3251 
    self.recv_markOrdersAsLocalConnected()
3252 
 
3253 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3254 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3255 
    args = markOrdersAsLocalConnected_args()
3256 
    args.providerId = providerId
3257 
    args.local_connected_orders = local_connected_orders
3258 
    args.write(self._oprot)
3259 
    self._oprot.writeMessageEnd()
3260 
    self._oprot.trans.flush()
3261 
 
3262 
  def recv_markOrdersAsLocalConnected(self, ):
3263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3264 
    if mtype == TMessageType.EXCEPTION:
3265 
      x = TApplicationException()
3266 
      x.read(self._iprot)
3267 
      self._iprot.readMessageEnd()
3268 
      raise x
3269 
    result = markOrdersAsLocalConnected_result()
3270 
    result.read(self._iprot)
3271 
    self._iprot.readMessageEnd()
3431 rajveer 3272 
    if result.ex is not None:
3064 chandransh 3273 
      raise result.ex
4910 phani.kuma 3274 
    return
1627 ankur.sing 3275 
 
4910 phani.kuma 3276 
  def getOrdersNotLocalConnected(self, providerId):
3277 
    """
3278 
    Returns a list of orders that were picked up or shipped but pending local connection.
3279 
 
3280 
    Parameters:
3281 
     - providerId
3282 
    """
3283 
    self.send_getOrdersNotLocalConnected(providerId)
3284 
    return self.recv_getOrdersNotLocalConnected()
3285 
 
3286 
  def send_getOrdersNotLocalConnected(self, providerId):
3287 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3288 
    args = getOrdersNotLocalConnected_args()
3289 
    args.providerId = providerId
3290 
    args.write(self._oprot)
3291 
    self._oprot.writeMessageEnd()
3292 
    self._oprot.trans.flush()
3293 
 
3294 
  def recv_getOrdersNotLocalConnected(self, ):
3295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3296 
    if mtype == TMessageType.EXCEPTION:
3297 
      x = TApplicationException()
3298 
      x.read(self._iprot)
3299 
      self._iprot.readMessageEnd()
3300 
      raise x
3301 
    result = getOrdersNotLocalConnected_result()
3302 
    result.read(self._iprot)
3303 
    self._iprot.readMessageEnd()
3304 
    if result.success is not None:
3305 
      return result.success
3306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3307 
 
3308 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3309 
    """
3310 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3311 
 
3312 
    Parameters:
3313 
     - providerId
3314 
     - destination_city_reached_orders
3315 
    """
3316 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3317 
    self.recv_markOrdersAsDestinationCityReached()
3318 
 
3319 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3320 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3321 
    args = markOrdersAsDestinationCityReached_args()
3322 
    args.providerId = providerId
3323 
    args.destination_city_reached_orders = destination_city_reached_orders
3324 
    args.write(self._oprot)
3325 
    self._oprot.writeMessageEnd()
3326 
    self._oprot.trans.flush()
3327 
 
3328 
  def recv_markOrdersAsDestinationCityReached(self, ):
3329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3330 
    if mtype == TMessageType.EXCEPTION:
3331 
      x = TApplicationException()
3332 
      x.read(self._iprot)
3333 
      self._iprot.readMessageEnd()
3334 
      raise x
3335 
    result = markOrdersAsDestinationCityReached_result()
3336 
    result.read(self._iprot)
3337 
    self._iprot.readMessageEnd()
3338 
    if result.ex is not None:
3339 
      raise result.ex
3340 
    return
3341 
 
3342 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3343 
    """
3344 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3345 
 
3346 
    Parameters:
3347 
     - providerId
3348 
     - first_atdl_orders
3349 
    """
3350 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3351 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3352 
 
3353 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3354 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3355 
    args = markOrdersAsFirstDeliveryAttempted_args()
3356 
    args.providerId = providerId
3357 
    args.first_atdl_orders = first_atdl_orders
3358 
    args.write(self._oprot)
3359 
    self._oprot.writeMessageEnd()
3360 
    self._oprot.trans.flush()
3361 
 
3362 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3364 
    if mtype == TMessageType.EXCEPTION:
3365 
      x = TApplicationException()
3366 
      x.read(self._iprot)
3367 
      self._iprot.readMessageEnd()
3368 
      raise x
3369 
    result = markOrdersAsFirstDeliveryAttempted_result()
3370 
    result.read(self._iprot)
3371 
    self._iprot.readMessageEnd()
3372 
    if result.ex is not None:
3373 
      raise result.ex
3374 
    return
3375 
 
3064 chandransh 3376 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3377 
    """
3064 chandransh 3378 
    Returns the list of orders whose delivery time has passed but have not been
3379 
    delivered yet for the given provider and warehouse. To get a complete list of
3380 
    undelivered orders, pass them as -1.
3381 
    Returns an empty list if no such orders exist.
3431 rajveer 3382 
 
1886 ankur.sing 3383 
    Parameters:
3064 chandransh 3384 
     - providerId
3385 
     - warehouseId
1886 ankur.sing 3386 
    """
3064 chandransh 3387 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3388 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3389 
 
3064 chandransh 3390 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3391 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3392 
    args = getUndeliveredOrders_args()
3393 
    args.providerId = providerId
3394 
    args.warehouseId = warehouseId
1886 ankur.sing 3395 
    args.write(self._oprot)
3396 
    self._oprot.writeMessageEnd()
3397 
    self._oprot.trans.flush()
3398 
 
3064 chandransh 3399 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3401 
    if mtype == TMessageType.EXCEPTION:
3402 
      x = TApplicationException()
3403 
      x.read(self._iprot)
3404 
      self._iprot.readMessageEnd()
3405 
      raise x
3064 chandransh 3406 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3407 
    result.read(self._iprot)
3408 
    self._iprot.readMessageEnd()
3431 rajveer 3409 
    if result.success is not None:
1886 ankur.sing 3410 
      return result.success
3064 chandransh 3411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3412 
 
4783 phani.kuma 3413 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3414 
    """
3415 
    Returns the list of orders whose expected delivery date has passed but have not been
3416 
    delivered yet.
3417 
    Returns an empty list if no such orders exist.
3418 
    """
3419 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3420 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3421 
 
3422 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3423 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3424 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3425 
    args.write(self._oprot)
3426 
    self._oprot.writeMessageEnd()
3427 
    self._oprot.trans.flush()
3428 
 
3429 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3431 
    if mtype == TMessageType.EXCEPTION:
3432 
      x = TApplicationException()
3433 
      x.read(self._iprot)
3434 
      self._iprot.readMessageEnd()
3435 
      raise x
3436 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3437 
    result.read(self._iprot)
3438 
    self._iprot.readMessageEnd()
3439 
    if result.success is not None:
3440 
      return result.success
3441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3442 
 
2536 chandransh 3443 
  def toggleDOAFlag(self, orderId):
3444 
    """
3445 
    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.
3446 
    Returns the final flag status.
3447 
    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 3448 
 
2536 chandransh 3449 
    Parameters:
3450 
     - orderId
3451 
    """
3452 
    self.send_toggleDOAFlag(orderId)
3453 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3454 
 
2536 chandransh 3455 
  def send_toggleDOAFlag(self, orderId):
3456 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3457 
    args = toggleDOAFlag_args()
3458 
    args.orderId = orderId
3459 
    args.write(self._oprot)
3460 
    self._oprot.writeMessageEnd()
3461 
    self._oprot.trans.flush()
3462 
 
3463 
  def recv_toggleDOAFlag(self, ):
3464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3465 
    if mtype == TMessageType.EXCEPTION:
3466 
      x = TApplicationException()
3467 
      x.read(self._iprot)
3468 
      self._iprot.readMessageEnd()
3469 
      raise x
3470 
    result = toggleDOAFlag_result()
3471 
    result.read(self._iprot)
3472 
    self._iprot.readMessageEnd()
3431 rajveer 3473 
    if result.success is not None:
2536 chandransh 3474 
      return result.success
3431 rajveer 3475 
    if result.ex is not None:
2536 chandransh 3476 
      raise result.ex
3477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3478 
 
4712 rajveer 3479 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3480 
    """
3481 
    Parameters:
3482 
     - orderId
3483 
     - deliveryTimestamp
3484 
     - receiver
3485 
    """
3486 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3487 
    self.recv_markOrderAsDelivered()
3488 
 
3489 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3490 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3491 
    args = markOrderAsDelivered_args()
3492 
    args.orderId = orderId
3493 
    args.deliveryTimestamp = deliveryTimestamp
3494 
    args.receiver = receiver
3495 
    args.write(self._oprot)
3496 
    self._oprot.writeMessageEnd()
3497 
    self._oprot.trans.flush()
3498 
 
3499 
  def recv_markOrderAsDelivered(self, ):
3500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3501 
    if mtype == TMessageType.EXCEPTION:
3502 
      x = TApplicationException()
3503 
      x.read(self._iprot)
3504 
      self._iprot.readMessageEnd()
3505 
      raise x
3506 
    result = markOrderAsDelivered_result()
3507 
    result.read(self._iprot)
3508 
    self._iprot.readMessageEnd()
3509 
    if result.ex is not None:
3510 
      raise result.ex
3511 
    return
3512 
 
5553 rajveer 3513 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3514 
    """
3515 
    Parameters:
3516 
     - orderId
3517 
     - deliveryTimestamp
3518 
    """
3519 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3520 
    self.recv_markOrderAsReceivedAtStore()
3521 
 
3522 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3523 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3524 
    args = markOrderAsReceivedAtStore_args()
3525 
    args.orderId = orderId
3526 
    args.deliveryTimestamp = deliveryTimestamp
3527 
    args.write(self._oprot)
3528 
    self._oprot.writeMessageEnd()
3529 
    self._oprot.trans.flush()
3530 
 
3531 
  def recv_markOrderAsReceivedAtStore(self, ):
3532 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3533 
    if mtype == TMessageType.EXCEPTION:
3534 
      x = TApplicationException()
3535 
      x.read(self._iprot)
3536 
      self._iprot.readMessageEnd()
3537 
      raise x
3538 
    result = markOrderAsReceivedAtStore_result()
3539 
    result.read(self._iprot)
3540 
    self._iprot.readMessageEnd()
3541 
    if result.ex is not None:
3542 
      raise result.ex
3543 
    return
3544 
 
4454 rajveer 3545 
  def markOrderDoaRequestReceived(self, orderId):
3546 
    """
3547 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3548 
 
3549 
    Parameters:
3550 
     - orderId
3551 
    """
3552 
    self.send_markOrderDoaRequestReceived(orderId)
3553 
    return self.recv_markOrderDoaRequestReceived()
3554 
 
3555 
  def send_markOrderDoaRequestReceived(self, orderId):
3556 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3557 
    args = markOrderDoaRequestReceived_args()
3558 
    args.orderId = orderId
3559 
    args.write(self._oprot)
3560 
    self._oprot.writeMessageEnd()
3561 
    self._oprot.trans.flush()
3562 
 
3563 
  def recv_markOrderDoaRequestReceived(self, ):
3564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3565 
    if mtype == TMessageType.EXCEPTION:
3566 
      x = TApplicationException()
3567 
      x.read(self._iprot)
3568 
      self._iprot.readMessageEnd()
3569 
      raise x
3570 
    result = markOrderDoaRequestReceived_result()
3571 
    result.read(self._iprot)
3572 
    self._iprot.readMessageEnd()
3573 
    if result.success is not None:
3574 
      return result.success
3575 
    if result.ex is not None:
3576 
      raise result.ex
3577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3578 
 
3579 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3580 
    """
3581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3582 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3583 
 
3584 
    Parameters:
3585 
     - orderId
3586 
     - isAuthorized
3587 
    """
3588 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3589 
    return self.recv_markOrderDoaRequestAuthorized()
3590 
 
3591 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3592 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3593 
    args = markOrderDoaRequestAuthorized_args()
3594 
    args.orderId = orderId
3595 
    args.isAuthorized = isAuthorized
3596 
    args.write(self._oprot)
3597 
    self._oprot.writeMessageEnd()
3598 
    self._oprot.trans.flush()
3599 
 
3600 
  def recv_markOrderDoaRequestAuthorized(self, ):
3601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3602 
    if mtype == TMessageType.EXCEPTION:
3603 
      x = TApplicationException()
3604 
      x.read(self._iprot)
3605 
      self._iprot.readMessageEnd()
3606 
      raise x
3607 
    result = markOrderDoaRequestAuthorized_result()
3608 
    result.read(self._iprot)
3609 
    self._iprot.readMessageEnd()
3610 
    if result.success is not None:
3611 
      return result.success
3612 
    if result.ex is not None:
3613 
      raise result.ex
3614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3615 
 
4488 rajveer 3616 
  def markOrderReturnRequestReceived(self, orderId):
3617 
    """
3618 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3619 
 
3620 
    Parameters:
3621 
     - orderId
3622 
    """
3623 
    self.send_markOrderReturnRequestReceived(orderId)
3624 
    return self.recv_markOrderReturnRequestReceived()
3625 
 
3626 
  def send_markOrderReturnRequestReceived(self, orderId):
3627 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3628 
    args = markOrderReturnRequestReceived_args()
3629 
    args.orderId = orderId
3630 
    args.write(self._oprot)
3631 
    self._oprot.writeMessageEnd()
3632 
    self._oprot.trans.flush()
3633 
 
3634 
  def recv_markOrderReturnRequestReceived(self, ):
3635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3636 
    if mtype == TMessageType.EXCEPTION:
3637 
      x = TApplicationException()
3638 
      x.read(self._iprot)
3639 
      self._iprot.readMessageEnd()
3640 
      raise x
3641 
    result = markOrderReturnRequestReceived_result()
3642 
    result.read(self._iprot)
3643 
    self._iprot.readMessageEnd()
3644 
    if result.success is not None:
3645 
      return result.success
3646 
    if result.ex is not None:
3647 
      raise result.ex
3648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3649 
 
3650 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3651 
    """
3652 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3653 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3654 
 
3655 
    Parameters:
3656 
     - orderId
3657 
     - isAuthorized
3658 
    """
3659 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3660 
    return self.recv_markOrderReturnRequestAuthorized()
3661 
 
3662 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3663 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3664 
    args = markOrderReturnRequestAuthorized_args()
3665 
    args.orderId = orderId
3666 
    args.isAuthorized = isAuthorized
3667 
    args.write(self._oprot)
3668 
    self._oprot.writeMessageEnd()
3669 
    self._oprot.trans.flush()
3670 
 
3671 
  def recv_markOrderReturnRequestAuthorized(self, ):
3672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3673 
    if mtype == TMessageType.EXCEPTION:
3674 
      x = TApplicationException()
3675 
      x.read(self._iprot)
3676 
      self._iprot.readMessageEnd()
3677 
      raise x
3678 
    result = markOrderReturnRequestAuthorized_result()
3679 
    result.read(self._iprot)
3680 
    self._iprot.readMessageEnd()
3681 
    if result.success is not None:
3682 
      return result.success
3683 
    if result.ex is not None:
3684 
      raise result.ex
3685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3686 
 
4579 rajveer 3687 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3688 
    """
3689 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3690 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3691 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3692 
    For any other status, it returns false.
3693 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3694 
 
2536 chandransh 3695 
    Parameters:
3696 
     - orderId
4579 rajveer 3697 
     - providerId
2536 chandransh 3698 
    """
4579 rajveer 3699 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3700 
    return self.recv_requestPickupNumber()
3701 
 
4579 rajveer 3702 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3703 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3704 
    args = requestPickupNumber_args()
3705 
    args.orderId = orderId
4579 rajveer 3706 
    args.providerId = providerId
2536 chandransh 3707 
    args.write(self._oprot)
3708 
    self._oprot.writeMessageEnd()
3709 
    self._oprot.trans.flush()
3710 
 
3711 
  def recv_requestPickupNumber(self, ):
3712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3713 
    if mtype == TMessageType.EXCEPTION:
3714 
      x = TApplicationException()
3715 
      x.read(self._iprot)
3716 
      self._iprot.readMessageEnd()
3717 
      raise x
3718 
    result = requestPickupNumber_result()
3719 
    result.read(self._iprot)
3720 
    self._iprot.readMessageEnd()
3431 rajveer 3721 
    if result.success is not None:
2536 chandransh 3722 
      return result.success
3431 rajveer 3723 
    if result.ex is not None:
2536 chandransh 3724 
      raise result.ex
3725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3726 
 
4602 rajveer 3727 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3728 
    """
4452 rajveer 3729 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3730 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3731 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3732 
    	3. Returns true
2591 chandransh 3733 
    If the order is in any other status, it returns false.
2536 chandransh 3734 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3735 
 
2536 chandransh 3736 
    Parameters:
3737 
     - orderId
3738 
     - pickupNumber
4602 rajveer 3739 
     - providerId
2536 chandransh 3740 
    """
4602 rajveer 3741 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3742 
    return self.recv_authorizePickup()
3743 
 
4602 rajveer 3744 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3745 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3746 
    args = authorizePickup_args()
3747 
    args.orderId = orderId
3748 
    args.pickupNumber = pickupNumber
4602 rajveer 3749 
    args.providerId = providerId
2536 chandransh 3750 
    args.write(self._oprot)
3751 
    self._oprot.writeMessageEnd()
3752 
    self._oprot.trans.flush()
3753 
 
3754 
  def recv_authorizePickup(self, ):
3755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3756 
    if mtype == TMessageType.EXCEPTION:
3757 
      x = TApplicationException()
3758 
      x.read(self._iprot)
3759 
      self._iprot.readMessageEnd()
3760 
      raise x
3761 
    result = authorizePickup_result()
3762 
    result.read(self._iprot)
3763 
    self._iprot.readMessageEnd()
3431 rajveer 3764 
    if result.success is not None:
2536 chandransh 3765 
      return result.success
3431 rajveer 3766 
    if result.ex is not None:
2536 chandransh 3767 
      raise result.ex
3768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3769 
 
2764 chandransh 3770 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3771 
    """
3772 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3773 
 
2764 chandransh 3774 
    Parameters:
3775 
     - providerId
3776 
     - pickupDetails
3777 
    """
3778 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3779 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3780 
 
3781 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3782 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3783 
    args = markDoasAsPickedUp_args()
3784 
    args.providerId = providerId
3785 
    args.pickupDetails = pickupDetails
3786 
    args.write(self._oprot)
3787 
    self._oprot.writeMessageEnd()
3788 
    self._oprot.trans.flush()
3789 
 
3790 
  def recv_markDoasAsPickedUp(self, ):
3791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3792 
    if mtype == TMessageType.EXCEPTION:
3793 
      x = TApplicationException()
3794 
      x.read(self._iprot)
3795 
      self._iprot.readMessageEnd()
3796 
      raise x
3797 
    result = markDoasAsPickedUp_result()
3798 
    result.read(self._iprot)
3799 
    self._iprot.readMessageEnd()
4910 phani.kuma 3800 
    return
3801 
 
3802 
  def getDoasNotPickedUp(self, providerId):
3803 
    """
3804 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3805 
 
3806 
    Parameters:
3807 
     - providerId
3808 
    """
3809 
    self.send_getDoasNotPickedUp(providerId)
3810 
    return self.recv_getDoasNotPickedUp()
3811 
 
3812 
  def send_getDoasNotPickedUp(self, providerId):
3813 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3814 
    args = getDoasNotPickedUp_args()
3815 
    args.providerId = providerId
3816 
    args.write(self._oprot)
3817 
    self._oprot.writeMessageEnd()
3818 
    self._oprot.trans.flush()
3819 
 
3820 
  def recv_getDoasNotPickedUp(self, ):
3821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3822 
    if mtype == TMessageType.EXCEPTION:
3823 
      x = TApplicationException()
3824 
      x.read(self._iprot)
3825 
      self._iprot.readMessageEnd()
3826 
      raise x
3827 
    result = getDoasNotPickedUp_result()
3828 
    result.read(self._iprot)
3829 
    self._iprot.readMessageEnd()
3431 rajveer 3830 
    if result.success is not None:
2764 chandransh 3831 
      return result.success
4910 phani.kuma 3832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3833 
 
4741 phani.kuma 3834 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3835 
    """
3836 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3837 
 
3838 
    Parameters:
3839 
     - providerId
3840 
     - pickupDetails
3841 
    """
3842 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3843 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3844 
 
3845 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3846 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3847 
    args = markReturnOrdersAsPickedUp_args()
3848 
    args.providerId = providerId
3849 
    args.pickupDetails = pickupDetails
3850 
    args.write(self._oprot)
3851 
    self._oprot.writeMessageEnd()
3852 
    self._oprot.trans.flush()
3853 
 
3854 
  def recv_markReturnOrdersAsPickedUp(self, ):
3855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3856 
    if mtype == TMessageType.EXCEPTION:
3857 
      x = TApplicationException()
3858 
      x.read(self._iprot)
3859 
      self._iprot.readMessageEnd()
3860 
      raise x
3861 
    result = markReturnOrdersAsPickedUp_result()
3862 
    result.read(self._iprot)
3863 
    self._iprot.readMessageEnd()
4910 phani.kuma 3864 
    return
3865 
 
3866 
  def getReturnOrdersNotPickedUp(self, providerId):
3867 
    """
3868 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3869 
 
3870 
    Parameters:
3871 
     - providerId
3872 
    """
3873 
    self.send_getReturnOrdersNotPickedUp(providerId)
3874 
    return self.recv_getReturnOrdersNotPickedUp()
3875 
 
3876 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3877 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3878 
    args = getReturnOrdersNotPickedUp_args()
3879 
    args.providerId = providerId
3880 
    args.write(self._oprot)
3881 
    self._oprot.writeMessageEnd()
3882 
    self._oprot.trans.flush()
3883 
 
3884 
  def recv_getReturnOrdersNotPickedUp(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 = getReturnOrdersNotPickedUp_result()
3892 
    result.read(self._iprot)
3893 
    self._iprot.readMessageEnd()
4741 phani.kuma 3894 
    if result.success is not None:
3895 
      return result.success
4910 phani.kuma 3896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3897 
 
4479 rajveer 3898 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3899 
    """
4452 rajveer 3900 
    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 3901 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3902 
    If the order is in any other state, it returns false.
3903 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3904 
 
2591 chandransh 3905 
    Parameters:
3906 
     - orderId
4479 rajveer 3907 
     - receiveCondition
2591 chandransh 3908 
    """
4479 rajveer 3909 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3910 
    return self.recv_receiveReturn()
2536 chandransh 3911 
 
4479 rajveer 3912 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3913 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3914 
    args = receiveReturn_args()
2591 chandransh 3915 
    args.orderId = orderId
4479 rajveer 3916 
    args.receiveCondition = receiveCondition
2591 chandransh 3917 
    args.write(self._oprot)
3918 
    self._oprot.writeMessageEnd()
3919 
    self._oprot.trans.flush()
3920 
 
2616 chandransh 3921 
  def recv_receiveReturn(self, ):
2591 chandransh 3922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3923 
    if mtype == TMessageType.EXCEPTION:
3924 
      x = TApplicationException()
3925 
      x.read(self._iprot)
3926 
      self._iprot.readMessageEnd()
3927 
      raise x
2616 chandransh 3928 
    result = receiveReturn_result()
2591 chandransh 3929 
    result.read(self._iprot)
3930 
    self._iprot.readMessageEnd()
3431 rajveer 3931 
    if result.success is not None:
2591 chandransh 3932 
      return result.success
3431 rajveer 3933 
    if result.ex is not None:
2591 chandransh 3934 
      raise result.ex
2616 chandransh 3935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3936 
 
3937 
  def validateDoa(self, orderId, isValid):
3938 
    """
4452 rajveer 3939 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3940 
    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 3941 
    If the order is in any other state, it returns false.
3942 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3943 
 
2591 chandransh 3944 
    Parameters:
3945 
     - orderId
3946 
     - isValid
3947 
    """
3948 
    self.send_validateDoa(orderId, isValid)
3949 
    return self.recv_validateDoa()
3950 
 
3951 
  def send_validateDoa(self, orderId, isValid):
3952 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3953 
    args = validateDoa_args()
3954 
    args.orderId = orderId
3955 
    args.isValid = isValid
3956 
    args.write(self._oprot)
3957 
    self._oprot.writeMessageEnd()
3958 
    self._oprot.trans.flush()
3959 
 
3960 
  def recv_validateDoa(self, ):
3961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3962 
    if mtype == TMessageType.EXCEPTION:
3963 
      x = TApplicationException()
3964 
      x.read(self._iprot)
3965 
      self._iprot.readMessageEnd()
3966 
      raise x
3967 
    result = validateDoa_result()
3968 
    result.read(self._iprot)
3969 
    self._iprot.readMessageEnd()
3431 rajveer 3970 
    if result.success is not None:
2591 chandransh 3971 
      return result.success
3431 rajveer 3972 
    if result.ex is not None:
2591 chandransh 3973 
      raise result.ex
3974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3975 
 
4495 rajveer 3976 
  def validateReturnProduct(self, orderId, isUsable):
3977 
    """
3978 
    Parameters:
3979 
     - orderId
3980 
     - isUsable
3981 
    """
3982 
    self.send_validateReturnProduct(orderId, isUsable)
3983 
    return self.recv_validateReturnProduct()
3984 
 
3985 
  def send_validateReturnProduct(self, orderId, isUsable):
3986 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3987 
    args = validateReturnProduct_args()
3988 
    args.orderId = orderId
3989 
    args.isUsable = isUsable
3990 
    args.write(self._oprot)
3991 
    self._oprot.writeMessageEnd()
3992 
    self._oprot.trans.flush()
3993 
 
3994 
  def recv_validateReturnProduct(self, ):
3995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3996 
    if mtype == TMessageType.EXCEPTION:
3997 
      x = TApplicationException()
3998 
      x.read(self._iprot)
3999 
      self._iprot.readMessageEnd()
4000 
      raise x
4001 
    result = validateReturnProduct_result()
4002 
    result.read(self._iprot)
4003 
    self._iprot.readMessageEnd()
4004 
    if result.success is not None:
4005 
      return result.success
4006 
    if result.ex is not None:
4007 
      raise result.ex
4008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
4009 
 
2616 chandransh 4010 
  def reshipOrder(self, orderId):
4011 
    """
4484 rajveer 4012 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 4013 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 4014 
    	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 4015 
 
4016 
    If the order is in DOA_CERT_VALID state, it does the following:
4017 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
4018 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 4019 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 4020 
 
2616 chandransh 4021 
    Returns the id of the newly created order.
3431 rajveer 4022 
 
2616 chandransh 4023 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4024 
 
2616 chandransh 4025 
    Parameters:
4026 
     - orderId
4027 
    """
4028 
    self.send_reshipOrder(orderId)
4029 
    return self.recv_reshipOrder()
2591 chandransh 4030 
 
2616 chandransh 4031 
  def send_reshipOrder(self, orderId):
4032 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
4033 
    args = reshipOrder_args()
4034 
    args.orderId = orderId
4035 
    args.write(self._oprot)
4036 
    self._oprot.writeMessageEnd()
4037 
    self._oprot.trans.flush()
4038 
 
4039 
  def recv_reshipOrder(self, ):
4040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4041 
    if mtype == TMessageType.EXCEPTION:
4042 
      x = TApplicationException()
4043 
      x.read(self._iprot)
4044 
      self._iprot.readMessageEnd()
4045 
      raise x
4046 
    result = reshipOrder_result()
4047 
    result.read(self._iprot)
4048 
    self._iprot.readMessageEnd()
3431 rajveer 4049 
    if result.success is not None:
2616 chandransh 4050 
      return result.success
3431 rajveer 4051 
    if result.ex is not None:
2616 chandransh 4052 
      raise result.ex
4053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
4054 
 
3226 chandransh 4055 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4056 
    """
4484 rajveer 4057 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 4058 
    	1. Creates a refund request for batch processing.
4059 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 4060 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 4061 
 
2616 chandransh 4062 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4063 
    	1. Creates a refund request for batch processing.
3226 chandransh 4064 
    	2. Cancels the reservation of the item in the warehouse.
4065 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 4066 
 
3226 chandransh 4067 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4068 
    	1. Cancels the reservation of the item in the warehouse.
4069 
    	2. Marks the current order as CANCELED.
4070 
 
4071 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
4072 
 
2616 chandransh 4073 
    Returns True if it is successful, False otherwise.
3431 rajveer 4074 
 
2616 chandransh 4075 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4076 
 
2616 chandransh 4077 
    Parameters:
4078 
     - orderId
3226 chandransh 4079 
     - refundedBy
4080 
     - reason
2616 chandransh 4081 
    """
3226 chandransh 4082 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 4083 
    return self.recv_refundOrder()
4084 
 
3226 chandransh 4085 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4086 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
4087 
    args = refundOrder_args()
4088 
    args.orderId = orderId
3226 chandransh 4089 
    args.refundedBy = refundedBy
4090 
    args.reason = reason
2616 chandransh 4091 
    args.write(self._oprot)
4092 
    self._oprot.writeMessageEnd()
4093 
    self._oprot.trans.flush()
4094 
 
4095 
  def recv_refundOrder(self, ):
4096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4097 
    if mtype == TMessageType.EXCEPTION:
4098 
      x = TApplicationException()
4099 
      x.read(self._iprot)
4100 
      self._iprot.readMessageEnd()
4101 
      raise x
4102 
    result = refundOrder_result()
4103 
    result.read(self._iprot)
4104 
    self._iprot.readMessageEnd()
3431 rajveer 4105 
    if result.success is not None:
2616 chandransh 4106 
      return result.success
3431 rajveer 4107 
    if result.ex is not None:
2616 chandransh 4108 
      raise result.ex
4109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4110 
 
2690 chandransh 4111 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4112 
    """
4113 
    Get all return orders created between the from and to dates for the given warehouse.
4114 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4115 
 
2690 chandransh 4116 
    Parameters:
4117 
     - warehouseId
4118 
     - fromDate
4119 
     - toDate
4120 
    """
4121 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4122 
    return self.recv_getReturnOrders()
2616 chandransh 4123 
 
2690 chandransh 4124 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4125 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4126 
    args = getReturnOrders_args()
4127 
    args.warehouseId = warehouseId
4128 
    args.fromDate = fromDate
4129 
    args.toDate = toDate
4130 
    args.write(self._oprot)
4131 
    self._oprot.writeMessageEnd()
4132 
    self._oprot.trans.flush()
4133 
 
4134 
  def recv_getReturnOrders(self, ):
4135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4136 
    if mtype == TMessageType.EXCEPTION:
4137 
      x = TApplicationException()
4138 
      x.read(self._iprot)
4139 
      self._iprot.readMessageEnd()
4140 
      raise x
4141 
    result = getReturnOrders_result()
4142 
    result.read(self._iprot)
4143 
    self._iprot.readMessageEnd()
3431 rajveer 4144 
    if result.success is not None:
2690 chandransh 4145 
      return result.success
4146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4147 
 
5481 phani.kuma 4148 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4149 
    """
4150 
    Get all return orders created between the from and to dates.
4151 
 
4152 
    Parameters:
4153 
     - onlyNotProcessed
4154 
     - fromDate
4155 
     - toDate
4156 
    """
4157 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4158 
    return self.recv_getAllReturnOrders()
4159 
 
4160 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4161 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4162 
    args = getAllReturnOrders_args()
4163 
    args.onlyNotProcessed = onlyNotProcessed
4164 
    args.fromDate = fromDate
4165 
    args.toDate = toDate
4166 
    args.write(self._oprot)
4167 
    self._oprot.writeMessageEnd()
4168 
    self._oprot.trans.flush()
4169 
 
4170 
  def recv_getAllReturnOrders(self, ):
4171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4172 
    if mtype == TMessageType.EXCEPTION:
4173 
      x = TApplicationException()
4174 
      x.read(self._iprot)
4175 
      self._iprot.readMessageEnd()
4176 
      raise x
4177 
    result = getAllReturnOrders_result()
4178 
    result.read(self._iprot)
4179 
    self._iprot.readMessageEnd()
4180 
    if result.success is not None:
4181 
      return result.success
4182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4183 
 
2700 chandransh 4184 
  def getReturnOrder(self, id):
4185 
    """
4186 
    Returns the ReturnOrder corresponding to the given id.
4187 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4188 
 
2700 chandransh 4189 
    Parameters:
4190 
     - id
4191 
    """
4192 
    self.send_getReturnOrder(id)
4193 
    return self.recv_getReturnOrder()
4194 
 
4195 
  def send_getReturnOrder(self, id):
4196 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4197 
    args = getReturnOrder_args()
4198 
    args.id = id
4199 
    args.write(self._oprot)
4200 
    self._oprot.writeMessageEnd()
4201 
    self._oprot.trans.flush()
4202 
 
4203 
  def recv_getReturnOrder(self, ):
4204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4205 
    if mtype == TMessageType.EXCEPTION:
4206 
      x = TApplicationException()
4207 
      x.read(self._iprot)
4208 
      self._iprot.readMessageEnd()
4209 
      raise x
4210 
    result = getReturnOrder_result()
4211 
    result.read(self._iprot)
4212 
    self._iprot.readMessageEnd()
3431 rajveer 4213 
    if result.success is not None:
2700 chandransh 4214 
      return result.success
3431 rajveer 4215 
    if result.ex is not None:
2700 chandransh 4216 
      raise result.ex
4217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4218 
 
2690 chandransh 4219 
  def processReturn(self, returnOrderId):
4220 
    """
4221 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4222 
 
2690 chandransh 4223 
    Parameters:
4224 
     - returnOrderId
4225 
    """
4226 
    self.send_processReturn(returnOrderId)
4227 
    self.recv_processReturn()
4228 
 
4229 
  def send_processReturn(self, returnOrderId):
4230 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4231 
    args = processReturn_args()
4232 
    args.returnOrderId = returnOrderId
4233 
    args.write(self._oprot)
4234 
    self._oprot.writeMessageEnd()
4235 
    self._oprot.trans.flush()
4236 
 
4237 
  def recv_processReturn(self, ):
4238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4239 
    if mtype == TMessageType.EXCEPTION:
4240 
      x = TApplicationException()
4241 
      x.read(self._iprot)
4242 
      self._iprot.readMessageEnd()
4243 
      raise x
4244 
    result = processReturn_result()
4245 
    result.read(self._iprot)
4246 
    self._iprot.readMessageEnd()
3431 rajveer 4247 
    if result.ex is not None:
2690 chandransh 4248 
      raise result.ex
4249 
    return
4250 
 
3451 chandransh 4251 
  def updateWeight(self, orderId, weight):
4252 
    """
4253 
    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 4254 
 
3451 chandransh 4255 
    Parameters:
4256 
     - orderId
4257 
     - weight
4258 
    """
4259 
    self.send_updateWeight(orderId, weight)
4260 
    return self.recv_updateWeight()
4261 
 
4262 
  def send_updateWeight(self, orderId, weight):
4263 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4264 
    args = updateWeight_args()
4265 
    args.orderId = orderId
4266 
    args.weight = weight
4267 
    args.write(self._oprot)
4268 
    self._oprot.writeMessageEnd()
4269 
    self._oprot.trans.flush()
4270 
 
4271 
  def recv_updateWeight(self, ):
4272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4273 
    if mtype == TMessageType.EXCEPTION:
4274 
      x = TApplicationException()
4275 
      x.read(self._iprot)
4276 
      self._iprot.readMessageEnd()
4277 
      raise x
4278 
    result = updateWeight_result()
4279 
    result.read(self._iprot)
4280 
    self._iprot.readMessageEnd()
4281 
    if result.success is not None:
4282 
      return result.success
4283 
    if result.ex is not None:
4284 
      raise result.ex
4285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4286 
 
3469 chandransh 4287 
  def changeItem(self, orderId, itemId):
4288 
    """
4289 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4290 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4291 
 
3469 chandransh 4292 
    Parameters:
4293 
     - orderId
4294 
     - itemId
4295 
    """
4296 
    self.send_changeItem(orderId, itemId)
4297 
    return self.recv_changeItem()
4298 
 
4299 
  def send_changeItem(self, orderId, itemId):
4300 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4301 
    args = changeItem_args()
4302 
    args.orderId = orderId
4303 
    args.itemId = itemId
4304 
    args.write(self._oprot)
4305 
    self._oprot.writeMessageEnd()
4306 
    self._oprot.trans.flush()
4307 
 
4308 
  def recv_changeItem(self, ):
4309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4310 
    if mtype == TMessageType.EXCEPTION:
4311 
      x = TApplicationException()
4312 
      x.read(self._iprot)
4313 
      self._iprot.readMessageEnd()
4314 
      raise x
4315 
    result = changeItem_result()
4316 
    result.read(self._iprot)
4317 
    self._iprot.readMessageEnd()
4318 
    if result.success is not None:
4319 
      return result.success
4320 
    if result.ex is not None:
4321 
      raise result.ex
4322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4323 
 
4324 
  def shiftToWarehouse(self, orderId, warehouseId):
4325 
    """
4326 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4327 
 
4328 
    Parameters:
4329 
     - orderId
4330 
     - warehouseId
4331 
    """
4332 
    self.send_shiftToWarehouse(orderId, warehouseId)
4333 
    return self.recv_shiftToWarehouse()
4334 
 
4335 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4336 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4337 
    args = shiftToWarehouse_args()
4338 
    args.orderId = orderId
4339 
    args.warehouseId = warehouseId
4340 
    args.write(self._oprot)
4341 
    self._oprot.writeMessageEnd()
4342 
    self._oprot.trans.flush()
4343 
 
4344 
  def recv_shiftToWarehouse(self, ):
4345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4346 
    if mtype == TMessageType.EXCEPTION:
4347 
      x = TApplicationException()
4348 
      x.read(self._iprot)
4349 
      self._iprot.readMessageEnd()
4350 
      raise x
4351 
    result = shiftToWarehouse_result()
4352 
    result.read(self._iprot)
4353 
    self._iprot.readMessageEnd()
4354 
    if result.success is not None:
4355 
      return result.success
4356 
    if result.ex is not None:
4357 
      raise result.ex
4358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4359 
 
4647 rajveer 4360 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4361 
    """
4362 
    Adds the given delay reason to the given order.
3986 chandransh 4363 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4364 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4365 
 
3553 chandransh 4366 
    Parameters:
4367 
     - orderId
4368 
     - delayReason
3986 chandransh 4369 
     - furtherDelay
4647 rajveer 4370 
     - delayReasonText
3553 chandransh 4371 
    """
4647 rajveer 4372 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4373 
    return self.recv_addDelayReason()
4374 
 
4647 rajveer 4375 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4376 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4377 
    args = addDelayReason_args()
4378 
    args.orderId = orderId
4379 
    args.delayReason = delayReason
3986 chandransh 4380 
    args.furtherDelay = furtherDelay
4647 rajveer 4381 
    args.delayReasonText = delayReasonText
3553 chandransh 4382 
    args.write(self._oprot)
4383 
    self._oprot.writeMessageEnd()
4384 
    self._oprot.trans.flush()
4385 
 
4386 
  def recv_addDelayReason(self, ):
4387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4388 
    if mtype == TMessageType.EXCEPTION:
4389 
      x = TApplicationException()
4390 
      x.read(self._iprot)
4391 
      self._iprot.readMessageEnd()
4392 
      raise x
4393 
    result = addDelayReason_result()
4394 
    result.read(self._iprot)
4395 
    self._iprot.readMessageEnd()
4396 
    if result.success is not None:
4397 
      return result.success
4398 
    if result.ex is not None:
4399 
      raise result.ex
4400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4401 
 
3956 chandransh 4402 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4403 
    """
4404 
    Marks the COD orders with given AWB nos. as having been processed.
4405 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4406 
 
3956 chandransh 4407 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4408 
    1. There is no order corresponding to an AWB number.
4409 
    2. The captured amount for a payment exceeds the total payment.
4410 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4411 
 
4412 
    Parameters:
4413 
     - collectedAmountMap
4414 
     - xferBy
4415 
     - xferTxnId
4416 
     - xferDate
4417 
    """
4418 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4419 
    return self.recv_reconcileCodCollection()
4420 
 
4421 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4422 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4423 
    args = reconcileCodCollection_args()
4424 
    args.collectedAmountMap = collectedAmountMap
4425 
    args.xferBy = xferBy
4426 
    args.xferTxnId = xferTxnId
4427 
    args.xferDate = xferDate
4428 
    args.write(self._oprot)
4429 
    self._oprot.writeMessageEnd()
4430 
    self._oprot.trans.flush()
4431 
 
4432 
  def recv_reconcileCodCollection(self, ):
4433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4434 
    if mtype == TMessageType.EXCEPTION:
4435 
      x = TApplicationException()
4436 
      x.read(self._iprot)
4437 
      self._iprot.readMessageEnd()
4438 
      raise x
4439 
    result = reconcileCodCollection_result()
4440 
    result.read(self._iprot)
4441 
    self._iprot.readMessageEnd()
4442 
    if result.success is not None:
4443 
      return result.success
4444 
    if result.ex is not None:
4445 
      raise result.ex
4446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4447 
 
4008 mandeep.dh 4448 
  def getTransactionsRequiringExtraProcessing(self, category):
4449 
    """
4065 mandeep.dh 4450 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4451 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4452 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4453 
 
4008 mandeep.dh 4454 
    Parameters:
4455 
     - category
4456 
    """
4457 
    self.send_getTransactionsRequiringExtraProcessing(category)
4458 
    return self.recv_getTransactionsRequiringExtraProcessing()
4459 
 
4460 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4461 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4462 
    args = getTransactionsRequiringExtraProcessing_args()
4463 
    args.category = category
4464 
    args.write(self._oprot)
4465 
    self._oprot.writeMessageEnd()
4466 
    self._oprot.trans.flush()
4467 
 
4468 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4470 
    if mtype == TMessageType.EXCEPTION:
4471 
      x = TApplicationException()
4472 
      x.read(self._iprot)
4473 
      self._iprot.readMessageEnd()
4474 
      raise x
4475 
    result = getTransactionsRequiringExtraProcessing_result()
4476 
    result.read(self._iprot)
4477 
    self._iprot.readMessageEnd()
4478 
    if result.success is not None:
4479 
      return result.success
4480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4481 
 
4482 
  def markTransactionAsProcessed(self, transactionId, category):
4483 
    """
4484 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4485 
    It essentially deletes the transaction id record for a particular
4486 
    processing type category (if present) from DB.
4487 
    This is currently used by CRM application.
4008 mandeep.dh 4488 
 
4489 
    Parameters:
4490 
     - transactionId
4491 
     - category
4492 
    """
4493 
    self.send_markTransactionAsProcessed(transactionId, category)
4494 
    self.recv_markTransactionAsProcessed()
4495 
 
4496 
  def send_markTransactionAsProcessed(self, transactionId, category):
4497 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4498 
    args = markTransactionAsProcessed_args()
4499 
    args.transactionId = transactionId
4500 
    args.category = category
4501 
    args.write(self._oprot)
4502 
    self._oprot.writeMessageEnd()
4503 
    self._oprot.trans.flush()
4504 
 
4505 
  def recv_markTransactionAsProcessed(self, ):
4506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4507 
    if mtype == TMessageType.EXCEPTION:
4508 
      x = TApplicationException()
4509 
      x.read(self._iprot)
4510 
      self._iprot.readMessageEnd()
4511 
      raise x
4512 
    result = markTransactionAsProcessed_result()
4513 
    result.read(self._iprot)
4514 
    self._iprot.readMessageEnd()
4515 
    return
4516 
 
4018 chandransh 4517 
  def getItemWiseRiskyOrdersCount(self, ):
4518 
    """
4519 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4520 
    is defined as one whose shipping date is about to expire.
4521 
    """
4522 
    self.send_getItemWiseRiskyOrdersCount()
4523 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4524 
 
4018 chandransh 4525 
  def send_getItemWiseRiskyOrdersCount(self, ):
4526 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4527 
    args = getItemWiseRiskyOrdersCount_args()
4528 
    args.write(self._oprot)
4529 
    self._oprot.writeMessageEnd()
4530 
    self._oprot.trans.flush()
4531 
 
4532 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4534 
    if mtype == TMessageType.EXCEPTION:
4535 
      x = TApplicationException()
4536 
      x.read(self._iprot)
4537 
      self._iprot.readMessageEnd()
4538 
      raise x
4539 
    result = getItemWiseRiskyOrdersCount_result()
4540 
    result.read(self._iprot)
4541 
    self._iprot.readMessageEnd()
4542 
    if result.success is not None:
4543 
      return result.success
4544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4545 
 
4295 varun.gupt 4546 
  def getOrdersForItemIds(self, itemIds):
4547 
    """
4548 
    Returns a list of all orders which have items with given id
4549 
 
4550 
    Parameters:
4551 
     - itemIds
4552 
    """
4553 
    self.send_getOrdersForItemIds(itemIds)
4554 
    return self.recv_getOrdersForItemIds()
4555 
 
4556 
  def send_getOrdersForItemIds(self, itemIds):
4557 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4558 
    args = getOrdersForItemIds_args()
4559 
    args.itemIds = itemIds
4560 
    args.write(self._oprot)
4561 
    self._oprot.writeMessageEnd()
4562 
    self._oprot.trans.flush()
4563 
 
4564 
  def recv_getOrdersForItemIds(self, ):
4565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4566 
    if mtype == TMessageType.EXCEPTION:
4567 
      x = TApplicationException()
4568 
      x.read(self._iprot)
4569 
      self._iprot.readMessageEnd()
4570 
      raise x
4571 
    result = getOrdersForItemIds_result()
4572 
    result.read(self._iprot)
4573 
    self._iprot.readMessageEnd()
4574 
    if result.success is not None:
4575 
      return result.success
4576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4577 
 
4247 rajveer 4578 
  def markOrderCancellationRequestReceived(self, orderId):
4579 
    """
4580 
    Mark order as cancellation request received. If customer sends request of cancellation of
4581 
    a particular order, this method will be called. It will just change status of the order
4582 
    depending on its current status. It also records the previous status, so that we can move
4583 
    back to that status if cancellation request is denied.
4018 chandransh 4584 
 
4247 rajveer 4585 
    Parameters:
4586 
     - orderId
4587 
    """
4588 
    self.send_markOrderCancellationRequestReceived(orderId)
4589 
    self.recv_markOrderCancellationRequestReceived()
4590 
 
4591 
  def send_markOrderCancellationRequestReceived(self, orderId):
4592 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4593 
    args = markOrderCancellationRequestReceived_args()
4594 
    args.orderId = orderId
4595 
    args.write(self._oprot)
4596 
    self._oprot.writeMessageEnd()
4597 
    self._oprot.trans.flush()
4598 
 
4599 
  def recv_markOrderCancellationRequestReceived(self, ):
4600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4601 
    if mtype == TMessageType.EXCEPTION:
4602 
      x = TApplicationException()
4603 
      x.read(self._iprot)
4604 
      self._iprot.readMessageEnd()
4605 
      raise x
4606 
    result = markOrderCancellationRequestReceived_result()
4607 
    result.read(self._iprot)
4608 
    self._iprot.readMessageEnd()
4609 
    if result.ex is not None:
4610 
      raise result.ex
4611 
    return
4612 
 
4613 
  def markOrderCancellationRequestConfirmed(self, orderId):
4614 
    """
4615 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4616 
    cancellation request confirmed. After this OM will be able to cancel the order.
4617 
 
4618 
    Parameters:
4619 
     - orderId
4620 
    """
4621 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4622 
    self.recv_markOrderCancellationRequestConfirmed()
4623 
 
4624 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4625 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4626 
    args = markOrderCancellationRequestConfirmed_args()
4627 
    args.orderId = orderId
4628 
    args.write(self._oprot)
4629 
    self._oprot.writeMessageEnd()
4630 
    self._oprot.trans.flush()
4631 
 
4632 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4634 
    if mtype == TMessageType.EXCEPTION:
4635 
      x = TApplicationException()
4636 
      x.read(self._iprot)
4637 
      self._iprot.readMessageEnd()
4638 
      raise x
4639 
    result = markOrderCancellationRequestConfirmed_result()
4640 
    result.read(self._iprot)
4641 
    self._iprot.readMessageEnd()
4642 
    if result.ex is not None:
4643 
      raise result.ex
4644 
    return
4645 
 
4646 
  def markOrderCancellationRequestDenied(self, orderId):
4647 
    """
4648 
    If we decide to not to cancel order, we will move the order ro previous status.
4649 
 
4650 
    Parameters:
4651 
     - orderId
4652 
    """
4653 
    self.send_markOrderCancellationRequestDenied(orderId)
4654 
    self.recv_markOrderCancellationRequestDenied()
4655 
 
4656 
  def send_markOrderCancellationRequestDenied(self, orderId):
4657 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4658 
    args = markOrderCancellationRequestDenied_args()
4659 
    args.orderId = orderId
4660 
    args.write(self._oprot)
4661 
    self._oprot.writeMessageEnd()
4662 
    self._oprot.trans.flush()
4663 
 
4664 
  def recv_markOrderCancellationRequestDenied(self, ):
4665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4666 
    if mtype == TMessageType.EXCEPTION:
4667 
      x = TApplicationException()
4668 
      x.read(self._iprot)
4669 
      self._iprot.readMessageEnd()
4670 
      raise x
4671 
    result = markOrderCancellationRequestDenied_result()
4672 
    result.read(self._iprot)
4673 
    self._iprot.readMessageEnd()
4674 
    if result.ex is not None:
4675 
      raise result.ex
4676 
    return
4677 
 
4258 rajveer 4678 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4679 
    """
4258 rajveer 4680 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4681 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4682 
 
4683 
    Parameters:
4258 rajveer 4684 
     - transactionId
4247 rajveer 4685 
    """
4258 rajveer 4686 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4687 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4688 
 
4258 rajveer 4689 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4690 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4691 
    args = markTransactionAsPaymentFlagRemoved_args()
4692 
    args.transactionId = transactionId
4247 rajveer 4693 
    args.write(self._oprot)
4694 
    self._oprot.writeMessageEnd()
4695 
    self._oprot.trans.flush()
4696 
 
4258 rajveer 4697 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4699 
    if mtype == TMessageType.EXCEPTION:
4700 
      x = TApplicationException()
4701 
      x.read(self._iprot)
4702 
      self._iprot.readMessageEnd()
4703 
      raise x
4258 rajveer 4704 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4705 
    result.read(self._iprot)
4706 
    self._iprot.readMessageEnd()
4707 
    if result.ex is not None:
4708 
      raise result.ex
4709 
    return
4710 
 
4259 anupam.sin 4711 
  def refundTransaction(self, transactionId, refundedBy, reason):
4712 
    """
4713 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4714 
    need to be cancelled
4247 rajveer 4715 
 
4259 anupam.sin 4716 
    Parameters:
4717 
     - transactionId
4718 
     - refundedBy
4719 
     - reason
4720 
    """
4721 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4722 
    self.recv_refundTransaction()
4723 
 
4724 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4725 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4726 
    args = refundTransaction_args()
4727 
    args.transactionId = transactionId
4728 
    args.refundedBy = refundedBy
4729 
    args.reason = reason
4730 
    args.write(self._oprot)
4731 
    self._oprot.writeMessageEnd()
4732 
    self._oprot.trans.flush()
4733 
 
4734 
  def recv_refundTransaction(self, ):
4735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4736 
    if mtype == TMessageType.EXCEPTION:
4737 
      x = TApplicationException()
4738 
      x.read(self._iprot)
4739 
      self._iprot.readMessageEnd()
4740 
      raise x
4741 
    result = refundTransaction_result()
4742 
    result.read(self._iprot)
4743 
    self._iprot.readMessageEnd()
4744 
    if result.ex is not None:
4745 
      raise result.ex
4746 
    return
4747 
 
4324 mandeep.dh 4748 
  def updateShipmentAddress(self, orderId, addressId):
4749 
    """
4750 
    Updates shipment address of an order. Delivery and shipping date estimates
4751 
    etc. are also updated here.
4752 
 
4753 
    Throws TransactionServiceException in case address change is not
4754 
    possible due to certain reasons such as new pincode in address is
4755 
    not serviceable etc.
4756 
 
4757 
    Parameters:
4758 
     - orderId
4759 
     - addressId
4760 
    """
4761 
    self.send_updateShipmentAddress(orderId, addressId)
4762 
    self.recv_updateShipmentAddress()
4763 
 
4764 
  def send_updateShipmentAddress(self, orderId, addressId):
4765 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4766 
    args = updateShipmentAddress_args()
4767 
    args.orderId = orderId
4768 
    args.addressId = addressId
4769 
    args.write(self._oprot)
4770 
    self._oprot.writeMessageEnd()
4771 
    self._oprot.trans.flush()
4772 
 
4773 
  def recv_updateShipmentAddress(self, ):
4774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4775 
    if mtype == TMessageType.EXCEPTION:
4776 
      x = TApplicationException()
4777 
      x.read(self._iprot)
4778 
      self._iprot.readMessageEnd()
4779 
      raise x
4780 
    result = updateShipmentAddress_result()
4781 
    result.read(self._iprot)
4782 
    self._iprot.readMessageEnd()
4783 
    if result.ex is not None:
4784 
      raise result.ex
4785 
    return
4786 
 
4285 rajveer 4787 
  def acceptOrdersForItemId(self, itemId, inventory):
4788 
    """
4789 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4790 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4791 
 
4285 rajveer 4792 
    Parameters:
4793 
     - itemId
4794 
     - inventory
4795 
    """
4796 
    self.send_acceptOrdersForItemId(itemId, inventory)
4797 
    return self.recv_acceptOrdersForItemId()
4798 
 
4799 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4800 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4801 
    args = acceptOrdersForItemId_args()
4802 
    args.itemId = itemId
4803 
    args.inventory = inventory
4804 
    args.write(self._oprot)
4805 
    self._oprot.writeMessageEnd()
4806 
    self._oprot.trans.flush()
4807 
 
4808 
  def recv_acceptOrdersForItemId(self, ):
4809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4810 
    if mtype == TMessageType.EXCEPTION:
4811 
      x = TApplicationException()
4812 
      x.read(self._iprot)
4813 
      self._iprot.readMessageEnd()
4814 
      raise x
4815 
    result = acceptOrdersForItemId_result()
4816 
    result.read(self._iprot)
4817 
    self._iprot.readMessageEnd()
4818 
    if result.success is not None:
4819 
      return result.success
4820 
    if result.ex is not None:
4821 
      raise result.ex
4822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4823 
 
4369 rajveer 4824 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4825 
    """
4826 
    Parameters:
4827 
     - vendorId
4828 
     - itemId
4829 
     - quantity
4830 
     - estimate
4369 rajveer 4831 
     - isReminder
4303 rajveer 4832 
    """
4369 rajveer 4833 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4834 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4835 
 
4369 rajveer 4836 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4837 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4838 
    args = markOrdersAsPORaised_args()
4839 
    args.vendorId = vendorId
4840 
    args.itemId = itemId
4841 
    args.quantity = quantity
4842 
    args.estimate = estimate
4369 rajveer 4843 
    args.isReminder = isReminder
4303 rajveer 4844 
    args.write(self._oprot)
4845 
    self._oprot.writeMessageEnd()
4846 
    self._oprot.trans.flush()
4847 
 
4848 
  def recv_markOrdersAsPORaised(self, ):
4849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4850 
    if mtype == TMessageType.EXCEPTION:
4851 
      x = TApplicationException()
4852 
      x.read(self._iprot)
4853 
      self._iprot.readMessageEnd()
4854 
      raise x
4855 
    result = markOrdersAsPORaised_result()
4856 
    result.read(self._iprot)
4857 
    self._iprot.readMessageEnd()
4858 
    if result.ex is not None:
4859 
      raise result.ex
4860 
    return
4861 
 
4369 rajveer 4862 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4863 
    """
4864 
    Parameters:
4865 
     - vendorId
4866 
     - itemId
4867 
     - quantity
4868 
     - estimate
4369 rajveer 4869 
     - isReminder
4303 rajveer 4870 
    """
4369 rajveer 4871 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4872 
    self.recv_markOrdersAsReversalInitiated()
4873 
 
4369 rajveer 4874 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4875 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4876 
    args = markOrdersAsReversalInitiated_args()
4877 
    args.vendorId = vendorId
4878 
    args.itemId = itemId
4879 
    args.quantity = quantity
4880 
    args.estimate = estimate
4369 rajveer 4881 
    args.isReminder = isReminder
4303 rajveer 4882 
    args.write(self._oprot)
4883 
    self._oprot.writeMessageEnd()
4884 
    self._oprot.trans.flush()
4885 
 
4886 
  def recv_markOrdersAsReversalInitiated(self, ):
4887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4888 
    if mtype == TMessageType.EXCEPTION:
4889 
      x = TApplicationException()
4890 
      x.read(self._iprot)
4891 
      self._iprot.readMessageEnd()
4892 
      raise x
4893 
    result = markOrdersAsReversalInitiated_result()
4894 
    result.read(self._iprot)
4895 
    self._iprot.readMessageEnd()
4896 
    if result.ex is not None:
4897 
      raise result.ex
4898 
    return
4899 
 
4369 rajveer 4900 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4901 
    """
4902 
    Parameters:
4903 
     - vendorId
4904 
     - itemId
4905 
     - quantity
4906 
     - estimate
4369 rajveer 4907 
     - isReminder
4303 rajveer 4908 
    """
4369 rajveer 4909 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4910 
    self.recv_markOrdersAsNotAvailabke()
4911 
 
4369 rajveer 4912 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4913 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4914 
    args = markOrdersAsNotAvailabke_args()
4915 
    args.vendorId = vendorId
4916 
    args.itemId = itemId
4917 
    args.quantity = quantity
4918 
    args.estimate = estimate
4369 rajveer 4919 
    args.isReminder = isReminder
4303 rajveer 4920 
    args.write(self._oprot)
4921 
    self._oprot.writeMessageEnd()
4922 
    self._oprot.trans.flush()
4923 
 
4924 
  def recv_markOrdersAsNotAvailabke(self, ):
4925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4926 
    if mtype == TMessageType.EXCEPTION:
4927 
      x = TApplicationException()
4928 
      x.read(self._iprot)
4929 
      self._iprot.readMessageEnd()
4930 
      raise x
4931 
    result = markOrdersAsNotAvailabke_result()
4932 
    result.read(self._iprot)
4933 
    self._iprot.readMessageEnd()
4934 
    if result.ex is not None:
4935 
      raise result.ex
4936 
    return
4937 
 
4369 rajveer 4938 
  def markOrdersAsTimeout(self, vendorId):
4939 
    """
4940 
    Parameters:
4941 
     - vendorId
4942 
    """
4943 
    self.send_markOrdersAsTimeout(vendorId)
4944 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4945 
 
4369 rajveer 4946 
  def send_markOrdersAsTimeout(self, vendorId):
4947 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4948 
    args = markOrdersAsTimeout_args()
4949 
    args.vendorId = vendorId
4950 
    args.write(self._oprot)
4951 
    self._oprot.writeMessageEnd()
4952 
    self._oprot.trans.flush()
4953 
 
4954 
  def recv_markOrdersAsTimeout(self, ):
4955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4956 
    if mtype == TMessageType.EXCEPTION:
4957 
      x = TApplicationException()
4958 
      x.read(self._iprot)
4959 
      self._iprot.readMessageEnd()
4960 
      raise x
4961 
    result = markOrdersAsTimeout_result()
4962 
    result.read(self._iprot)
4963 
    self._iprot.readMessageEnd()
4964 
    if result.success is not None:
4965 
      return result.success
4966 
    if result.ex is not None:
4967 
      raise result.ex
4968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4969 
 
4662 rajveer 4970 
  def markOrderAsLostInTransit(self, orderId):
4971 
    """
4972 
    Mark order as LOST_IN_TRANSIT
4973 
 
4974 
    Parameters:
4975 
     - orderId
4976 
    """
4977 
    self.send_markOrderAsLostInTransit(orderId)
4978 
    return self.recv_markOrderAsLostInTransit()
4979 
 
4980 
  def send_markOrderAsLostInTransit(self, orderId):
4981 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4982 
    args = markOrderAsLostInTransit_args()
4983 
    args.orderId = orderId
4984 
    args.write(self._oprot)
4985 
    self._oprot.writeMessageEnd()
4986 
    self._oprot.trans.flush()
4987 
 
4988 
  def recv_markOrderAsLostInTransit(self, ):
4989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4990 
    if mtype == TMessageType.EXCEPTION:
4991 
      x = TApplicationException()
4992 
      x.read(self._iprot)
4993 
      self._iprot.readMessageEnd()
4994 
      raise x
4995 
    result = markOrderAsLostInTransit_result()
4996 
    result.read(self._iprot)
4997 
    self._iprot.readMessageEnd()
4998 
    if result.success is not None:
4999 
      return result.success
5000 
    if result.ex is not None:
5001 
      raise result.ex
5002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
5003 
 
4386 anupam.sin 5004 
  def getOrderForAwb(self, awb):
5005 
    """
5006 
    Returns the order corresponding to an AWB number
4369 rajveer 5007 
 
4386 anupam.sin 5008 
    Parameters:
5009 
     - awb
5010 
    """
5011 
    self.send_getOrderForAwb(awb)
5012 
    return self.recv_getOrderForAwb()
5013 
 
5014 
  def send_getOrderForAwb(self, awb):
5015 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
5016 
    args = getOrderForAwb_args()
5017 
    args.awb = awb
5018 
    args.write(self._oprot)
5019 
    self._oprot.writeMessageEnd()
5020 
    self._oprot.trans.flush()
5021 
 
5022 
  def recv_getOrderForAwb(self, ):
5023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5024 
    if mtype == TMessageType.EXCEPTION:
5025 
      x = TApplicationException()
5026 
      x.read(self._iprot)
5027 
      self._iprot.readMessageEnd()
5028 
      raise x
5029 
    result = getOrderForAwb_result()
5030 
    result.read(self._iprot)
5031 
    self._iprot.readMessageEnd()
5032 
    if result.success is not None:
5033 
      return result.success
5034 
    if result.ex is not None:
5035 
      raise result.ex
5036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
5037 
 
4910 phani.kuma 5038 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 5039 
    """
4910 phani.kuma 5040 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 5041 
 
4506 phani.kuma 5042 
    Parameters:
5043 
     - logistics_provider_id
4910 phani.kuma 5044 
     - order_status_list
4506 phani.kuma 5045 
    """
4910 phani.kuma 5046 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 5047 
    return self.recv_getOrdersForProviderForStatus()
5048 
 
4910 phani.kuma 5049 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 5050 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
5051 
    args = getOrdersForProviderForStatus_args()
5052 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 5053 
    args.order_status_list = order_status_list
4506 phani.kuma 5054 
    args.write(self._oprot)
5055 
    self._oprot.writeMessageEnd()
5056 
    self._oprot.trans.flush()
5057 
 
5058 
  def recv_getOrdersForProviderForStatus(self, ):
5059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5060 
    if mtype == TMessageType.EXCEPTION:
5061 
      x = TApplicationException()
5062 
      x.read(self._iprot)
5063 
      self._iprot.readMessageEnd()
5064 
      raise x
5065 
    result = getOrdersForProviderForStatus_result()
5066 
    result.read(self._iprot)
5067 
    self._iprot.readMessageEnd()
5068 
    if result.success is not None:
5069 
      return result.success
5070 
    if result.ex is not None:
5071 
      raise result.ex
5072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
5073 
 
4600 varun.gupt 5074 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5075 
    """
5076 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 5077 
 
4600 varun.gupt 5078 
    Parameters:
5079 
     - vendorId
5080 
     - billingDateFrom
5081 
     - billingDateTo
5082 
    """
5083 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
5084 
    return self.recv_getBilledOrdersForVendor()
5085 
 
5086 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5087 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
5088 
    args = getBilledOrdersForVendor_args()
5089 
    args.vendorId = vendorId
5090 
    args.billingDateFrom = billingDateFrom
5091 
    args.billingDateTo = billingDateTo
5092 
    args.write(self._oprot)
5093 
    self._oprot.writeMessageEnd()
5094 
    self._oprot.trans.flush()
5095 
 
5096 
  def recv_getBilledOrdersForVendor(self, ):
5097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5098 
    if mtype == TMessageType.EXCEPTION:
5099 
      x = TApplicationException()
5100 
      x.read(self._iprot)
5101 
      self._iprot.readMessageEnd()
5102 
      raise x
5103 
    result = getBilledOrdersForVendor_result()
5104 
    result.read(self._iprot)
5105 
    self._iprot.readMessageEnd()
5106 
    if result.success is not None:
5107 
      return result.success
5108 
    if result.ex is not None:
5109 
      raise result.ex
5110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5111 
 
4607 rajveer 5112 
  def getSlippedSippingDateOrders(self, ):
5113 
    self.send_getSlippedSippingDateOrders()
5114 
    return self.recv_getSlippedSippingDateOrders()
5115 
 
5116 
  def send_getSlippedSippingDateOrders(self, ):
5117 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5118 
    args = getSlippedSippingDateOrders_args()
5119 
    args.write(self._oprot)
5120 
    self._oprot.writeMessageEnd()
5121 
    self._oprot.trans.flush()
5122 
 
5123 
  def recv_getSlippedSippingDateOrders(self, ):
5124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5125 
    if mtype == TMessageType.EXCEPTION:
5126 
      x = TApplicationException()
5127 
      x.read(self._iprot)
5128 
      self._iprot.readMessageEnd()
5129 
      raise x
5130 
    result = getSlippedSippingDateOrders_result()
5131 
    result.read(self._iprot)
5132 
    self._iprot.readMessageEnd()
5133 
    if result.success is not None:
5134 
      return result.success
5135 
    if result.ex is not None:
5136 
      raise result.ex
5137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5138 
 
4709 rajveer 5139 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5140 
    """
5141 
    Parameters:
5142 
     - cancelDateFrom
5143 
     - cancelDateTo
5144 
    """
5145 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5146 
    return self.recv_getCancelledOrders()
5147 
 
5148 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5149 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5150 
    args = getCancelledOrders_args()
5151 
    args.cancelDateFrom = cancelDateFrom
5152 
    args.cancelDateTo = cancelDateTo
5153 
    args.write(self._oprot)
5154 
    self._oprot.writeMessageEnd()
5155 
    self._oprot.trans.flush()
5156 
 
5157 
  def recv_getCancelledOrders(self, ):
5158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5159 
    if mtype == TMessageType.EXCEPTION:
5160 
      x = TApplicationException()
5161 
      x.read(self._iprot)
5162 
      self._iprot.readMessageEnd()
5163 
      raise x
5164 
    result = getCancelledOrders_result()
5165 
    result.read(self._iprot)
5166 
    self._iprot.readMessageEnd()
5167 
    if result.success is not None:
5168 
      return result.success
5169 
    if result.ex is not None:
5170 
      raise result.ex
5171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5172 
 
4600 varun.gupt 5173 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5174 
    """
5175 
    Parameters:
5176 
     - mapAWBAndAmount
5177 
    """
5178 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5179 
    self.recv_saveBluedartSettlements()
5180 
 
5181 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5182 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5183 
    args = saveBluedartSettlements_args()
5184 
    args.mapAWBAndAmount = mapAWBAndAmount
5185 
    args.write(self._oprot)
5186 
    self._oprot.writeMessageEnd()
5187 
    self._oprot.trans.flush()
5188 
 
5189 
  def recv_saveBluedartSettlements(self, ):
5190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5191 
    if mtype == TMessageType.EXCEPTION:
5192 
      x = TApplicationException()
5193 
      x.read(self._iprot)
5194 
      self._iprot.readMessageEnd()
5195 
      raise x
5196 
    result = saveBluedartSettlements_result()
5197 
    result.read(self._iprot)
5198 
    self._iprot.readMessageEnd()
5199 
    if result.ex is not None:
5200 
      raise result.ex
5201 
    return
5202 
 
4905 varun.gupt 5203 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5204 
    """
5205 
    Parameters:
5206 
     - settlementDate
5207 
     - paymentGatewayId
4905 varun.gupt 5208 
     - referenceId
4600 varun.gupt 5209 
     - serviceTax
5210 
     - otherCharges
5211 
     - netCollection
5212 
    """
4905 varun.gupt 5213 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5214 
    self.recv_savePaymentSettlements()
5215 
 
4905 varun.gupt 5216 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5217 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5218 
    args = savePaymentSettlements_args()
5219 
    args.settlementDate = settlementDate
5220 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5221 
    args.referenceId = referenceId
4600 varun.gupt 5222 
    args.serviceTax = serviceTax
5223 
    args.otherCharges = otherCharges
5224 
    args.netCollection = netCollection
5225 
    args.write(self._oprot)
5226 
    self._oprot.writeMessageEnd()
5227 
    self._oprot.trans.flush()
5228 
 
5229 
  def recv_savePaymentSettlements(self, ):
5230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5231 
    if mtype == TMessageType.EXCEPTION:
5232 
      x = TApplicationException()
5233 
      x.read(self._iprot)
5234 
      self._iprot.readMessageEnd()
5235 
      raise x
5236 
    result = savePaymentSettlements_result()
5237 
    result.read(self._iprot)
5238 
    self._iprot.readMessageEnd()
5239 
    if result.ex is not None:
5240 
      raise result.ex
5241 
    return
5242 
 
5243 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5244 
    """
5245 
    Parameters:
5246 
     - settlementId
5247 
     - settlementDate
5248 
     - transactionDateFrom
5249 
     - transactionDateTo
5250 
     - amount
5251 
    """
5252 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5253 
    self.recv_saveEBSSettlementSummary()
5254 
 
5255 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5256 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5257 
    args = saveEBSSettlementSummary_args()
5258 
    args.settlementId = settlementId
5259 
    args.settlementDate = settlementDate
5260 
    args.transactionDateFrom = transactionDateFrom
5261 
    args.transactionDateTo = transactionDateTo
5262 
    args.amount = amount
5263 
    args.write(self._oprot)
5264 
    self._oprot.writeMessageEnd()
5265 
    self._oprot.trans.flush()
5266 
 
5267 
  def recv_saveEBSSettlementSummary(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 = saveEBSSettlementSummary_result()
5275 
    result.read(self._iprot)
5276 
    self._iprot.readMessageEnd()
5277 
    if result.ex is not None:
5278 
      raise result.ex
5279 
    return
5280 
 
5386 phani.kuma 5281 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5282 
    """
5283 
    Parameters:
5189 varun.gupt 5284 
     - referenceId
5285 
     - isRefund
4600 varun.gupt 5286 
    """
5386 phani.kuma 5287 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5288 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5289 
 
5386 phani.kuma 5290 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5291 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5292 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5293 
    args.referenceId = referenceId
5294 
    args.isRefund = isRefund
4600 varun.gupt 5295 
    args.write(self._oprot)
5296 
    self._oprot.writeMessageEnd()
5297 
    self._oprot.trans.flush()
5298 
 
5386 phani.kuma 5299 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5301 
    if mtype == TMessageType.EXCEPTION:
5302 
      x = TApplicationException()
5303 
      x.read(self._iprot)
5304 
      self._iprot.readMessageEnd()
5305 
      raise x
5386 phani.kuma 5306 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5307 
    result.read(self._iprot)
5308 
    self._iprot.readMessageEnd()
5309 
    if result.success is not None:
5310 
      return result.success
5311 
    if result.ex is not None:
5312 
      raise result.ex
5386 phani.kuma 5313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5314 
 
5386 phani.kuma 5315 
  def getSettlementForCod(self, orderId, isRefund):
5316 
    """
5317 
    Parameters:
5318 
     - orderId
5319 
     - isRefund
5320 
    """
5321 
    self.send_getSettlementForCod(orderId, isRefund)
5322 
    return self.recv_getSettlementForCod()
5323 
 
5324 
  def send_getSettlementForCod(self, orderId, isRefund):
5325 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5326 
    args = getSettlementForCod_args()
5327 
    args.orderId = orderId
5328 
    args.isRefund = isRefund
5329 
    args.write(self._oprot)
5330 
    self._oprot.writeMessageEnd()
5331 
    self._oprot.trans.flush()
5332 
 
5333 
  def recv_getSettlementForCod(self, ):
5334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5335 
    if mtype == TMessageType.EXCEPTION:
5336 
      x = TApplicationException()
5337 
      x.read(self._iprot)
5338 
      self._iprot.readMessageEnd()
5339 
      raise x
5340 
    result = getSettlementForCod_result()
5341 
    result.read(self._iprot)
5342 
    self._iprot.readMessageEnd()
5343 
    if result.success is not None:
5344 
      return result.success
5345 
    if result.ex is not None:
5346 
      raise result.ex
5347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5348 
 
4600 varun.gupt 5349 
  def getEBSSettlementSummaries(self, ):
5350 
    self.send_getEBSSettlementSummaries()
5351 
    return self.recv_getEBSSettlementSummaries()
5352 
 
5353 
  def send_getEBSSettlementSummaries(self, ):
5354 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5355 
    args = getEBSSettlementSummaries_args()
5356 
    args.write(self._oprot)
5357 
    self._oprot.writeMessageEnd()
5358 
    self._oprot.trans.flush()
5359 
 
5360 
  def recv_getEBSSettlementSummaries(self, ):
5361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5362 
    if mtype == TMessageType.EXCEPTION:
5363 
      x = TApplicationException()
5364 
      x.read(self._iprot)
5365 
      self._iprot.readMessageEnd()
5366 
      raise x
5367 
    result = getEBSSettlementSummaries_result()
5368 
    result.read(self._iprot)
5369 
    self._iprot.readMessageEnd()
5370 
    if result.success is not None:
5371 
      return result.success
5372 
    if result.ex is not None:
5373 
      raise result.ex
5374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5375 
 
5376 
  def markEBSSettlementUploaded(self, settlementId):
5377 
    """
5378 
    Parameters:
5379 
     - settlementId
5380 
    """
5381 
    self.send_markEBSSettlementUploaded(settlementId)
5382 
    self.recv_markEBSSettlementUploaded()
5383 
 
5384 
  def send_markEBSSettlementUploaded(self, settlementId):
5385 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5386 
    args = markEBSSettlementUploaded_args()
5387 
    args.settlementId = settlementId
5388 
    args.write(self._oprot)
5389 
    self._oprot.writeMessageEnd()
5390 
    self._oprot.trans.flush()
5391 
 
5392 
  def recv_markEBSSettlementUploaded(self, ):
5393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5394 
    if mtype == TMessageType.EXCEPTION:
5395 
      x = TApplicationException()
5396 
      x.read(self._iprot)
5397 
      self._iprot.readMessageEnd()
5398 
      raise x
5399 
    result = markEBSSettlementUploaded_result()
5400 
    result.read(self._iprot)
5401 
    self._iprot.readMessageEnd()
5402 
    if result.ex is not None:
5403 
      raise result.ex
5404 
    return
5405 
 
5406 
  def getEBSSettlementDate(self, settlementId):
5407 
    """
5408 
    Parameters:
5409 
     - settlementId
5410 
    """
5411 
    self.send_getEBSSettlementDate(settlementId)
5412 
    return self.recv_getEBSSettlementDate()
5413 
 
5414 
  def send_getEBSSettlementDate(self, settlementId):
5415 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5416 
    args = getEBSSettlementDate_args()
5417 
    args.settlementId = settlementId
5418 
    args.write(self._oprot)
5419 
    self._oprot.writeMessageEnd()
5420 
    self._oprot.trans.flush()
5421 
 
5422 
  def recv_getEBSSettlementDate(self, ):
5423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5424 
    if mtype == TMessageType.EXCEPTION:
5425 
      x = TApplicationException()
5426 
      x.read(self._iprot)
5427 
      self._iprot.readMessageEnd()
5428 
      raise x
5429 
    result = getEBSSettlementDate_result()
5430 
    result.read(self._iprot)
5431 
    self._iprot.readMessageEnd()
5432 
    if result.success is not None:
5433 
      return result.success
5434 
    if result.ex is not None:
5435 
      raise result.ex
5436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5437 
 
4715 varun.gupt 5438 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5439 
    """
5440 
    Parameters:
5441 
     - settlementDateFrom
5442 
     - settlementDateTo
5443 
     - isRefund
5444 
    """
5445 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5446 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5447 
 
4715 varun.gupt 5448 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5449 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5450 
    args = getSettlementsByDate_args()
5451 
    args.settlementDateFrom = settlementDateFrom
5452 
    args.settlementDateTo = settlementDateTo
5453 
    args.isRefund = isRefund
5454 
    args.write(self._oprot)
5455 
    self._oprot.writeMessageEnd()
5456 
    self._oprot.trans.flush()
5457 
 
5458 
  def recv_getSettlementsByDate(self, ):
5459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5460 
    if mtype == TMessageType.EXCEPTION:
5461 
      x = TApplicationException()
5462 
      x.read(self._iprot)
5463 
      self._iprot.readMessageEnd()
5464 
      raise x
5465 
    result = getSettlementsByDate_result()
5466 
    result.read(self._iprot)
5467 
    self._iprot.readMessageEnd()
5468 
    if result.success is not None:
5469 
      return result.success
5470 
    if result.ex is not None:
5471 
      raise result.ex
5472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5473 
 
5474 
  def getReshippedOrderIds(self, orderIds):
5475 
    """
5476 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5477 
 
5478 
    Parameters:
5479 
     - orderIds
5480 
    """
5481 
    self.send_getReshippedOrderIds(orderIds)
5482 
    return self.recv_getReshippedOrderIds()
5483 
 
5484 
  def send_getReshippedOrderIds(self, orderIds):
5485 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5486 
    args = getReshippedOrderIds_args()
5487 
    args.orderIds = orderIds
5488 
    args.write(self._oprot)
5489 
    self._oprot.writeMessageEnd()
5490 
    self._oprot.trans.flush()
5491 
 
5492 
  def recv_getReshippedOrderIds(self, ):
5493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5494 
    if mtype == TMessageType.EXCEPTION:
5495 
      x = TApplicationException()
5496 
      x.read(self._iprot)
5497 
      self._iprot.readMessageEnd()
5498 
      raise x
5499 
    result = getReshippedOrderIds_result()
5500 
    result.read(self._iprot)
5501 
    self._iprot.readMessageEnd()
5502 
    if result.success is not None:
5503 
      return result.success
5504 
    if result.ex is not None:
5505 
      raise result.ex
5506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5507 
 
5481 phani.kuma 5508 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5509 
    """
5510 
    Parameters:
5511 
     - vendorId
5481 phani.kuma 5512 
     - onlyVendorNotPaid
5513 
     - billingDateFrom
5514 
     - billingDateTo
4875 varun.gupt 5515 
    """
5481 phani.kuma 5516 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5517 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5518 
 
5481 phani.kuma 5519 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5520 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5521 
    args = getBilledOrders_args()
4875 varun.gupt 5522 
    args.vendorId = vendorId
5481 phani.kuma 5523 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5524 
    args.billingDateFrom = billingDateFrom
5525 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5526 
    args.write(self._oprot)
5527 
    self._oprot.writeMessageEnd()
5528 
    self._oprot.trans.flush()
5529 
 
5481 phani.kuma 5530 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5532 
    if mtype == TMessageType.EXCEPTION:
5533 
      x = TApplicationException()
5534 
      x.read(self._iprot)
5535 
      self._iprot.readMessageEnd()
5536 
      raise x
5481 phani.kuma 5537 
    result = getBilledOrders_result()
4875 varun.gupt 5538 
    result.read(self._iprot)
5539 
    self._iprot.readMessageEnd()
5540 
    if result.success is not None:
5541 
      return result.success
5542 
    if result.ex is not None:
5543 
      raise result.ex
5481 phani.kuma 5544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5545 
 
5031 varun.gupt 5546 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5547 
    """
5548 
    Parameters:
5549 
     - startDate
5550 
     - endDate
5551 
    """
5552 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5553 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5554 
 
5031 varun.gupt 5555 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5556 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5557 
    args = getStatusDistributionOfOrders_args()
5558 
    args.startDate = startDate
5559 
    args.endDate = endDate
5560 
    args.write(self._oprot)
5561 
    self._oprot.writeMessageEnd()
5562 
    self._oprot.trans.flush()
5563 
 
5564 
  def recv_getStatusDistributionOfOrders(self, ):
5565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5566 
    if mtype == TMessageType.EXCEPTION:
5567 
      x = TApplicationException()
5568 
      x.read(self._iprot)
5569 
      self._iprot.readMessageEnd()
5570 
      raise x
5571 
    result = getStatusDistributionOfOrders_result()
5572 
    result.read(self._iprot)
5573 
    self._iprot.readMessageEnd()
5574 
    if result.success is not None:
5575 
      return result.success
5576 
    if result.ex is not None:
5577 
      raise result.ex
5578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5579 
 
5067 varun.gupt 5580 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5581 
    """
5582 
    Parameters:
5583 
     - status
5584 
     - startDatetime
5585 
     - endDatetime
5586 
    """
5587 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5588 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5589 
 
5067 varun.gupt 5590 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5591 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5592 
    args = getOrderIdsForStatus_args()
5593 
    args.status = status
5594 
    args.startDatetime = startDatetime
5595 
    args.endDatetime = endDatetime
5596 
    args.write(self._oprot)
5597 
    self._oprot.writeMessageEnd()
5598 
    self._oprot.trans.flush()
5599 
 
5600 
  def recv_getOrderIdsForStatus(self, ):
5601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5602 
    if mtype == TMessageType.EXCEPTION:
5603 
      x = TApplicationException()
5604 
      x.read(self._iprot)
5605 
      self._iprot.readMessageEnd()
5606 
      raise x
5607 
    result = getOrderIdsForStatus_result()
5608 
    result.read(self._iprot)
5609 
    self._iprot.readMessageEnd()
5610 
    if result.success is not None:
5611 
      return result.success
5612 
    if result.ex is not None:
5613 
      raise result.ex
5614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5615 
 
5348 anupam.sin 5616 
  def updateCODAgent(self, agent, orderId):
5617 
    """
5618 
    Updates the agent who handled the COD verification call
5619 
 
5620 
    Parameters:
5621 
     - agent
5622 
     - orderId
5623 
    """
5624 
    self.send_updateCODAgent(agent, orderId)
5625 
    self.recv_updateCODAgent()
5626 
 
5627 
  def send_updateCODAgent(self, agent, orderId):
5628 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5629 
    args = updateCODAgent_args()
5630 
    args.agent = agent
5631 
    args.orderId = orderId
5632 
    args.write(self._oprot)
5633 
    self._oprot.writeMessageEnd()
5634 
    self._oprot.trans.flush()
5635 
 
5636 
  def recv_updateCODAgent(self, ):
5637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5638 
    if mtype == TMessageType.EXCEPTION:
5639 
      x = TApplicationException()
5640 
      x.read(self._iprot)
5641 
      self._iprot.readMessageEnd()
5642 
      raise x
5643 
    result = updateCODAgent_result()
5644 
    result.read(self._iprot)
5645 
    self._iprot.readMessageEnd()
5646 
    if result.ex is not None:
5647 
      raise result.ex
5648 
    return
5649 
 
5099 varun.gupt 5650 
  def updateOrderAsPaidToVendor(self, orderId):
5651 
    """
5652 
    Parameters:
5653 
     - orderId
5654 
    """
5655 
    self.send_updateOrderAsPaidToVendor(orderId)
5656 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5657 
 
5099 varun.gupt 5658 
  def send_updateOrderAsPaidToVendor(self, orderId):
5659 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5660 
    args = updateOrderAsPaidToVendor_args()
5661 
    args.orderId = orderId
5662 
    args.write(self._oprot)
5663 
    self._oprot.writeMessageEnd()
5664 
    self._oprot.trans.flush()
5665 
 
5666 
  def recv_updateOrderAsPaidToVendor(self, ):
5667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5668 
    if mtype == TMessageType.EXCEPTION:
5669 
      x = TApplicationException()
5670 
      x.read(self._iprot)
5671 
      self._iprot.readMessageEnd()
5672 
      raise x
5673 
    result = updateOrderAsPaidToVendor_result()
5674 
    result.read(self._iprot)
5675 
    self._iprot.readMessageEnd()
5676 
    if result.ex is not None:
5677 
      raise result.ex
5678 
    return
5679 
 
5386 phani.kuma 5680 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5681 
    """
5682 
    Parameters:
5683 
     - orderId
5684 
    """
5685 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5686 
    self.recv_updateOrderOnlyAsPaidToVendor()
5687 
 
5688 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5689 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5690 
    args = updateOrderOnlyAsPaidToVendor_args()
5691 
    args.orderId = orderId
5692 
    args.write(self._oprot)
5693 
    self._oprot.writeMessageEnd()
5694 
    self._oprot.trans.flush()
5695 
 
5696 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5698 
    if mtype == TMessageType.EXCEPTION:
5699 
      x = TApplicationException()
5700 
      x.read(self._iprot)
5701 
      self._iprot.readMessageEnd()
5702 
      raise x
5703 
    result = updateOrderOnlyAsPaidToVendor_result()
5704 
    result.read(self._iprot)
5705 
    self._iprot.readMessageEnd()
5706 
    if result.ex is not None:
5707 
      raise result.ex
5708 
    return
5709 
 
5208 varun.gupt 5710 
  def getRefundedOrdersMarkedPaid(self, ):
5711 
    self.send_getRefundedOrdersMarkedPaid()
5712 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5713 
 
5208 varun.gupt 5714 
  def send_getRefundedOrdersMarkedPaid(self, ):
5715 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5716 
    args = getRefundedOrdersMarkedPaid_args()
5717 
    args.write(self._oprot)
5718 
    self._oprot.writeMessageEnd()
5719 
    self._oprot.trans.flush()
5720 
 
5721 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5723 
    if mtype == TMessageType.EXCEPTION:
5724 
      x = TApplicationException()
5725 
      x.read(self._iprot)
5726 
      self._iprot.readMessageEnd()
5727 
      raise x
5728 
    result = getRefundedOrdersMarkedPaid_result()
5729 
    result.read(self._iprot)
5730 
    self._iprot.readMessageEnd()
5731 
    if result.success is not None:
5732 
      return result.success
5733 
    if result.ex is not None:
5734 
      raise result.ex
5735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5736 
 
5447 anupam.sin 5737 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5738 
    """
5739 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5740 
 
5447 anupam.sin 5741 
 
5742 
    Parameters:
5743 
     - minOrderId
5744 
     - maxOrderId
5745 
    """
5746 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5747 
    return self.recv_getAllVerificationAgents()
5748 
 
5749 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5750 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5751 
    args = getAllVerificationAgents_args()
5752 
    args.minOrderId = minOrderId
5753 
    args.maxOrderId = maxOrderId
5754 
    args.write(self._oprot)
5755 
    self._oprot.writeMessageEnd()
5756 
    self._oprot.trans.flush()
5757 
 
5758 
  def recv_getAllVerificationAgents(self, ):
5759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5760 
    if mtype == TMessageType.EXCEPTION:
5761 
      x = TApplicationException()
5762 
      x.read(self._iprot)
5763 
      self._iprot.readMessageEnd()
5764 
      raise x
5765 
    result = getAllVerificationAgents_result()
5766 
    result.read(self._iprot)
5767 
    self._iprot.readMessageEnd()
5768 
    if result.success is not None:
5769 
      return result.success
5770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5771 
 
5527 anupam.sin 5772 
  def getAllAttributesForOrderId(self, orderId):
5773 
    """
5774 
    gets all attributes for a given orderId
5447 anupam.sin 5775 
 
5527 anupam.sin 5776 
    Parameters:
5777 
     - orderId
5778 
    """
5779 
    self.send_getAllAttributesForOrderId(orderId)
5780 
    return self.recv_getAllAttributesForOrderId()
5781 
 
5782 
  def send_getAllAttributesForOrderId(self, orderId):
5783 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5784 
    args = getAllAttributesForOrderId_args()
5785 
    args.orderId = orderId
5786 
    args.write(self._oprot)
5787 
    self._oprot.writeMessageEnd()
5788 
    self._oprot.trans.flush()
5789 
 
5790 
  def recv_getAllAttributesForOrderId(self, ):
5791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5792 
    if mtype == TMessageType.EXCEPTION:
5793 
      x = TApplicationException()
5794 
      x.read(self._iprot)
5795 
      self._iprot.readMessageEnd()
5796 
      raise x
5797 
    result = getAllAttributesForOrderId_result()
5798 
    result.read(self._iprot)
5799 
    self._iprot.readMessageEnd()
5800 
    if result.success is not None:
5801 
      return result.success
5802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5803 
 
5676 rajveer 5804 
  def setOrderAttributes(self, orderId, attributes):
5805 
    """
5806 
    sets attributes for an order
5807 
 
5808 
    Parameters:
5809 
     - orderId
5810 
     - attributes
5811 
    """
5812 
    self.send_setOrderAttributes(orderId, attributes)
5813 
    self.recv_setOrderAttributes()
5814 
 
5815 
  def send_setOrderAttributes(self, orderId, attributes):
5816 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5817 
    args = setOrderAttributes_args()
5818 
    args.orderId = orderId
5819 
    args.attributes = attributes
5820 
    args.write(self._oprot)
5821 
    self._oprot.writeMessageEnd()
5822 
    self._oprot.trans.flush()
5823 
 
5824 
  def recv_setOrderAttributes(self, ):
5825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5826 
    if mtype == TMessageType.EXCEPTION:
5827 
      x = TApplicationException()
5828 
      x.read(self._iprot)
5829 
      self._iprot.readMessageEnd()
5830 
      raise x
5831 
    result = setOrderAttributes_result()
5832 
    result.read(self._iprot)
5833 
    self._iprot.readMessageEnd()
5834 
    return
5835 
 
5527 anupam.sin 5836 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5837 
    """
5838 
    sets attributes for all orders in a transaction
5839 
 
5840 
    Parameters:
5841 
     - transactionId
5842 
     - attribute
5843 
    """
5844 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5845 
    self.recv_setOrderAttributeForTransaction()
5846 
 
5847 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5848 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5849 
    args = setOrderAttributeForTransaction_args()
5850 
    args.transactionId = transactionId
5851 
    args.attribute = attribute
5852 
    args.write(self._oprot)
5853 
    self._oprot.writeMessageEnd()
5854 
    self._oprot.trans.flush()
5855 
 
5856 
  def recv_setOrderAttributeForTransaction(self, ):
5857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5858 
    if mtype == TMessageType.EXCEPTION:
5859 
      x = TApplicationException()
5860 
      x.read(self._iprot)
5861 
      self._iprot.readMessageEnd()
5862 
      raise x
5863 
    result = setOrderAttributeForTransaction_result()
5864 
    result.read(self._iprot)
5865 
    self._iprot.readMessageEnd()
5866 
    return
5867 
 
5553 rajveer 5868 
  def getReceivePendingOrders(self, storeId):
5869 
    """
5870 
    Parameters:
5871 
     - storeId
5872 
    """
5873 
    self.send_getReceivePendingOrders(storeId)
5874 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5875 
 
5553 rajveer 5876 
  def send_getReceivePendingOrders(self, storeId):
5877 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5878 
    args = getReceivePendingOrders_args()
5879 
    args.storeId = storeId
5880 
    args.write(self._oprot)
5881 
    self._oprot.writeMessageEnd()
5882 
    self._oprot.trans.flush()
5883 
 
5884 
  def recv_getReceivePendingOrders(self, ):
5885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5886 
    if mtype == TMessageType.EXCEPTION:
5887 
      x = TApplicationException()
5888 
      x.read(self._iprot)
5889 
      self._iprot.readMessageEnd()
5890 
      raise x
5891 
    result = getReceivePendingOrders_result()
5892 
    result.read(self._iprot)
5893 
    self._iprot.readMessageEnd()
5894 
    if result.success is not None:
5895 
      return result.success
5896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5897 
 
5898 
  def getReceivedAtStoreOrders(self, storeId):
5899 
    """
5900 
    Parameters:
5901 
     - storeId
5902 
    """
5903 
    self.send_getReceivedAtStoreOrders(storeId)
5904 
    return self.recv_getReceivedAtStoreOrders()
5905 
 
5906 
  def send_getReceivedAtStoreOrders(self, storeId):
5907 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5908 
    args = getReceivedAtStoreOrders_args()
5909 
    args.storeId = storeId
5910 
    args.write(self._oprot)
5911 
    self._oprot.writeMessageEnd()
5912 
    self._oprot.trans.flush()
5913 
 
5914 
  def recv_getReceivedAtStoreOrders(self, ):
5915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5916 
    if mtype == TMessageType.EXCEPTION:
5917 
      x = TApplicationException()
5918 
      x.read(self._iprot)
5919 
      self._iprot.readMessageEnd()
5920 
      raise x
5921 
    result = getReceivedAtStoreOrders_result()
5922 
    result.read(self._iprot)
5923 
    self._iprot.readMessageEnd()
5924 
    if result.success is not None:
5925 
      return result.success
5926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5927 
 
5713 rajveer 5928 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5929 
    """
5930 
    Parameters:
5931 
     - storeId
5932 
     - fromDate
5933 
     - toDate
5934 
     - onlyCod
5935 
    """
5936 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5937 
    return self.recv_getOrdersCollectionAtStore()
5938 
 
5939 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5940 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5941 
    args = getOrdersCollectionAtStore_args()
5942 
    args.storeId = storeId
5943 
    args.fromDate = fromDate
5944 
    args.toDate = toDate
5945 
    args.onlyCod = onlyCod
5946 
    args.write(self._oprot)
5947 
    self._oprot.writeMessageEnd()
5948 
    self._oprot.trans.flush()
5949 
 
5950 
  def recv_getOrdersCollectionAtStore(self, ):
5951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5952 
    if mtype == TMessageType.EXCEPTION:
5953 
      x = TApplicationException()
5954 
      x.read(self._iprot)
5955 
      self._iprot.readMessageEnd()
5956 
      raise x
5957 
    result = getOrdersCollectionAtStore_result()
5958 
    result.read(self._iprot)
5959 
    self._iprot.readMessageEnd()
5960 
    if result.success is not None:
5961 
      return result.success
5962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5963 
 
5833 rajveer 5964 
  def getOrderAttributeValue(self, orderId, attributeName):
5965 
    """
5966 
    Parameters:
5967 
     - orderId
5968 
     - attributeName
5969 
    """
5970 
    self.send_getOrderAttributeValue(orderId, attributeName)
5971 
    return self.recv_getOrderAttributeValue()
5972 
 
5973 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5974 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5975 
    args = getOrderAttributeValue_args()
5976 
    args.orderId = orderId
5977 
    args.attributeName = attributeName
5978 
    args.write(self._oprot)
5979 
    self._oprot.writeMessageEnd()
5980 
    self._oprot.trans.flush()
5981 
 
5982 
  def recv_getOrderAttributeValue(self, ):
5983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5984 
    if mtype == TMessageType.EXCEPTION:
5985 
      x = TApplicationException()
5986 
      x.read(self._iprot)
5987 
      self._iprot.readMessageEnd()
5988 
      raise x
5989 
    result = getOrderAttributeValue_result()
5990 
    result.read(self._iprot)
5991 
    self._iprot.readMessageEnd()
5992 
    if result.success is not None:
5993 
      return result.success
5994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5995 
 
6019 rajveer 5996 
  def changeJacketNumber(self, orderId, jacketNumber):
5997 
    """
5998 
    Parameters:
5999 
     - orderId
6000 
     - jacketNumber
6001 
    """
6002 
    self.send_changeJacketNumber(orderId, jacketNumber)
6003 
    return self.recv_changeJacketNumber()
6004 
 
6005 
  def send_changeJacketNumber(self, orderId, jacketNumber):
6006 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
6007 
    args = changeJacketNumber_args()
6008 
    args.orderId = orderId
6009 
    args.jacketNumber = jacketNumber
6010 
    args.write(self._oprot)
6011 
    self._oprot.writeMessageEnd()
6012 
    self._oprot.trans.flush()
6013 
 
6014 
  def recv_changeJacketNumber(self, ):
6015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6016 
    if mtype == TMessageType.EXCEPTION:
6017 
      x = TApplicationException()
6018 
      x.read(self._iprot)
6019 
      self._iprot.readMessageEnd()
6020 
      raise x
6021 
    result = changeJacketNumber_result()
6022 
    result.read(self._iprot)
6023 
    self._iprot.readMessageEnd()
6024 
    if result.success is not None:
6025 
      return result.success
6026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
6027 
 
6028 
  def markOrderAsRtoInTransit(self, orderId):
6029 
    """
6030 
    Parameters:
6031 
     - orderId
6032 
    """
6033 
    self.send_markOrderAsRtoInTransit(orderId)
6034 
    return self.recv_markOrderAsRtoInTransit()
6035 
 
6036 
  def send_markOrderAsRtoInTransit(self, orderId):
6037 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
6038 
    args = markOrderAsRtoInTransit_args()
6039 
    args.orderId = orderId
6040 
    args.write(self._oprot)
6041 
    self._oprot.writeMessageEnd()
6042 
    self._oprot.trans.flush()
6043 
 
6044 
  def recv_markOrderAsRtoInTransit(self, ):
6045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6046 
    if mtype == TMessageType.EXCEPTION:
6047 
      x = TApplicationException()
6048 
      x.read(self._iprot)
6049 
      self._iprot.readMessageEnd()
6050 
      raise x
6051 
    result = markOrderAsRtoInTransit_result()
6052 
    result.read(self._iprot)
6053 
    self._iprot.readMessageEnd()
6054 
    if result.success is not None:
6055 
      return result.success
6056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
6057 
 
5593 mandeep.dh 6058 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6059 
    """
6060 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
6061 
    invoked while scanning IN of items.
5553 rajveer 6062 
 
5593 mandeep.dh 6063 
    Parameters:
6064 
     - itemId
6065 
     - quantity
6066 
     - fulfilmentWarehouseId
6067 
     - billingWarehouseId
6068 
    """
6069 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
6070 
    self.recv_acceptOrderForItem()
6071 
 
6072 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6073 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
6074 
    args = acceptOrderForItem_args()
6075 
    args.itemId = itemId
6076 
    args.quantity = quantity
6077 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
6078 
    args.billingWarehouseId = billingWarehouseId
6079 
    args.write(self._oprot)
6080 
    self._oprot.writeMessageEnd()
6081 
    self._oprot.trans.flush()
6082 
 
6083 
  def recv_acceptOrderForItem(self, ):
6084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6085 
    if mtype == TMessageType.EXCEPTION:
6086 
      x = TApplicationException()
6087 
      x.read(self._iprot)
6088 
      self._iprot.readMessageEnd()
6089 
      raise x
6090 
    result = acceptOrderForItem_result()
6091 
    result.read(self._iprot)
6092 
    self._iprot.readMessageEnd()
6093 
    return
6094 
 
6000 mandeep.dh 6095 
  def createRechargeOrder(self, rechargeOrder):
6096 
    """
6097 
    Parameters:
6098 
     - rechargeOrder
6099 
    """
6100 
    self.send_createRechargeOrder(rechargeOrder)
6101 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6102 
 
6000 mandeep.dh 6103 
  def send_createRechargeOrder(self, rechargeOrder):
6104 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6105 
    args = createRechargeOrder_args()
6106 
    args.rechargeOrder = rechargeOrder
6107 
    args.write(self._oprot)
6108 
    self._oprot.writeMessageEnd()
6109 
    self._oprot.trans.flush()
6110 
 
6111 
  def recv_createRechargeOrder(self, ):
6112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6113 
    if mtype == TMessageType.EXCEPTION:
6114 
      x = TApplicationException()
6115 
      x.read(self._iprot)
6116 
      self._iprot.readMessageEnd()
6117 
      raise x
6118 
    result = createRechargeOrder_result()
6119 
    result.read(self._iprot)
6120 
    self._iprot.readMessageEnd()
6121 
    if result.success is not None:
6122 
      return result.success
6123 
    if result.ex is not None:
6124 
      raise result.ex
6125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6126 
 
6031 rajveer 6127 
  def getRechargeOrder(self, rechargeRrderId):
6128 
    """
6129 
    Parameters:
6130 
     - rechargeRrderId
6131 
    """
6132 
    self.send_getRechargeOrder(rechargeRrderId)
6133 
    return self.recv_getRechargeOrder()
6134 
 
6135 
  def send_getRechargeOrder(self, rechargeRrderId):
6136 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6137 
    args = getRechargeOrder_args()
6138 
    args.rechargeRrderId = rechargeRrderId
6139 
    args.write(self._oprot)
6140 
    self._oprot.writeMessageEnd()
6141 
    self._oprot.trans.flush()
6142 
 
6143 
  def recv_getRechargeOrder(self, ):
6144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6145 
    if mtype == TMessageType.EXCEPTION:
6146 
      x = TApplicationException()
6147 
      x.read(self._iprot)
6148 
      self._iprot.readMessageEnd()
6149 
      raise x
6150 
    result = getRechargeOrder_result()
6151 
    result.read(self._iprot)
6152 
    self._iprot.readMessageEnd()
6153 
    if result.success is not None:
6154 
      return result.success
6155 
    if result.ex is not None:
6156 
      raise result.ex
6157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6158 
 
6159 
  def getRechargeOrders(self, userId):
6160 
    """
6161 
    Parameters:
6162 
     - userId
6163 
    """
6164 
    self.send_getRechargeOrders(userId)
6165 
    return self.recv_getRechargeOrders()
6166 
 
6167 
  def send_getRechargeOrders(self, userId):
6168 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6169 
    args = getRechargeOrders_args()
6170 
    args.userId = userId
6171 
    args.write(self._oprot)
6172 
    self._oprot.writeMessageEnd()
6173 
    self._oprot.trans.flush()
6174 
 
6175 
  def recv_getRechargeOrders(self, ):
6176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6177 
    if mtype == TMessageType.EXCEPTION:
6178 
      x = TApplicationException()
6179 
      x.read(self._iprot)
6180 
      self._iprot.readMessageEnd()
6181 
      raise x
6182 
    result = getRechargeOrders_result()
6183 
    result.read(self._iprot)
6184 
    self._iprot.readMessageEnd()
6185 
    if result.success is not None:
6186 
      return result.success
6187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6188 
 
6000 mandeep.dh 6189 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6190 
    """
6191 
    Parameters:
6192 
     - rechargeOrderId
6193 
     - rechargeOrderStatus
6194 
    """
6195 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6196 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6197 
 
6198 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6199 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6200 
    args = updateRechargeOrderStatus_args()
6201 
    args.rechargeOrderId = rechargeOrderId
6202 
    args.rechargeOrderStatus = rechargeOrderStatus
6203 
    args.write(self._oprot)
6204 
    self._oprot.writeMessageEnd()
6205 
    self._oprot.trans.flush()
6206 
 
6207 
  def recv_updateRechargeOrderStatus(self, ):
6208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6209 
    if mtype == TMessageType.EXCEPTION:
6210 
      x = TApplicationException()
6211 
      x.read(self._iprot)
6212 
      self._iprot.readMessageEnd()
6213 
      raise x
6214 
    result = updateRechargeOrderStatus_result()
6215 
    result.read(self._iprot)
6216 
    self._iprot.readMessageEnd()
6031 rajveer 6217 
    if result.success is not None:
6218 
      return result.success
6000 mandeep.dh 6219 
    if result.ex is not None:
6220 
      raise result.ex
6031 rajveer 6221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6222 
 
6031 rajveer 6223 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6224 
    """
6225 
    Parameters:
6031 rajveer 6226 
     - rechargeOrderId
6000 mandeep.dh 6227 
    """
6031 rajveer 6228 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6229 
    return self.recv_activateRechargeTxn()
6230 
 
6031 rajveer 6231 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6232 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6233 
    args = activateRechargeTxn_args()
6031 rajveer 6234 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6235 
    args.write(self._oprot)
6236 
    self._oprot.writeMessageEnd()
6237 
    self._oprot.trans.flush()
6238 
 
6239 
  def recv_activateRechargeTxn(self, ):
6240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6241 
    if mtype == TMessageType.EXCEPTION:
6242 
      x = TApplicationException()
6243 
      x.read(self._iprot)
6244 
      self._iprot.readMessageEnd()
6245 
      raise x
6246 
    result = activateRechargeTxn_result()
6247 
    result.read(self._iprot)
6248 
    self._iprot.readMessageEnd()
6249 
    if result.success is not None:
6250 
      return result.success
6251 
    if result.ex is not None:
6252 
      raise result.ex
6253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6254 
 
6031 rajveer 6255 
  def getUserWallet(self, userId):
6000 mandeep.dh 6256 
    """
6257 
    Parameters:
6031 rajveer 6258 
     - userId
6000 mandeep.dh 6259 
    """
6031 rajveer 6260 
    self.send_getUserWallet(userId)
6261 
    return self.recv_getUserWallet()
6000 mandeep.dh 6262 
 
6031 rajveer 6263 
  def send_getUserWallet(self, userId):
6264 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6265 
    args = getUserWallet_args()
6266 
    args.userId = userId
6000 mandeep.dh 6267 
    args.write(self._oprot)
6268 
    self._oprot.writeMessageEnd()
6269 
    self._oprot.trans.flush()
6270 
 
6031 rajveer 6271 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6273 
    if mtype == TMessageType.EXCEPTION:
6274 
      x = TApplicationException()
6275 
      x.read(self._iprot)
6276 
      self._iprot.readMessageEnd()
6277 
      raise x
6031 rajveer 6278 
    result = getUserWallet_result()
6000 mandeep.dh 6279 
    result.read(self._iprot)
6280 
    self._iprot.readMessageEnd()
6281 
    if result.success is not None:
6282 
      return result.success
6031 rajveer 6283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6284 
 
6031 rajveer 6285 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6286 
    """
6287 
    Parameters:
6031 rajveer 6288 
     - userId
6000 mandeep.dh 6289 
    """
6031 rajveer 6290 
    self.send_getUserWalletHistory(userId)
6291 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6292 
 
6031 rajveer 6293 
  def send_getUserWalletHistory(self, userId):
6294 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6295 
    args = getUserWalletHistory_args()
6296 
    args.userId = userId
6000 mandeep.dh 6297 
    args.write(self._oprot)
6298 
    self._oprot.writeMessageEnd()
6299 
    self._oprot.trans.flush()
6300 
 
6031 rajveer 6301 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6303 
    if mtype == TMessageType.EXCEPTION:
6304 
      x = TApplicationException()
6305 
      x.read(self._iprot)
6306 
      self._iprot.readMessageEnd()
6307 
      raise x
6031 rajveer 6308 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6309 
    result.read(self._iprot)
6310 
    self._iprot.readMessageEnd()
6311 
    if result.success is not None:
6312 
      return result.success
6031 rajveer 6313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6314 
 
6050 anupam.sin 6315 
  def getRechargeOrdersForTransaction(self, txnId):
6316 
    """
6317 
    Returns a recharge order for a given transactionId
6318 
 
6319 
    Parameters:
6320 
     - txnId
6321 
    """
6322 
    self.send_getRechargeOrdersForTransaction(txnId)
6323 
    return self.recv_getRechargeOrdersForTransaction()
6324 
 
6325 
  def send_getRechargeOrdersForTransaction(self, txnId):
6326 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6327 
    args = getRechargeOrdersForTransaction_args()
6328 
    args.txnId = txnId
6329 
    args.write(self._oprot)
6330 
    self._oprot.writeMessageEnd()
6331 
    self._oprot.trans.flush()
6332 
 
6333 
  def recv_getRechargeOrdersForTransaction(self, ):
6334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6335 
    if mtype == TMessageType.EXCEPTION:
6336 
      x = TApplicationException()
6337 
      x.read(self._iprot)
6338 
      self._iprot.readMessageEnd()
6339 
      raise x
6340 
    result = getRechargeOrdersForTransaction_result()
6341 
    result.read(self._iprot)
6342 
    self._iprot.readMessageEnd()
6343 
    if result.success is not None:
6344 
      return result.success
6345 
    if result.ex is not None:
6346 
      raise result.ex
6347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6348 
 
6206 rajveer 6349 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6350 
    """
6351 
    Parameters:
6352 
     - rechargeType
6206 rajveer 6353 
     - onlyActive
6048 rajveer 6354 
    """
6206 rajveer 6355 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6356 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6357 
 
6206 rajveer 6358 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6359 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6360 
    args = getServiceProviders_args()
6361 
    args.rechargeType = rechargeType
6206 rajveer 6362 
    args.onlyActive = onlyActive
6048 rajveer 6363 
    args.write(self._oprot)
6364 
    self._oprot.writeMessageEnd()
6365 
    self._oprot.trans.flush()
6366 
 
6367 
  def recv_getServiceProviders(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 = getServiceProviders_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, "getServiceProviders failed: unknown result");
6380 
 
6049 rajveer 6381 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6382 
    """
6383 
    Parameters:
6049 rajveer 6384 
     - rechargeType
6048 rajveer 6385 
     - deviceNumber
6386 
    """
6049 rajveer 6387 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6388 
    return self.recv_getServiceProviderForDevice()
6389 
 
6049 rajveer 6390 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6391 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6392 
    args = getServiceProviderForDevice_args()
6049 rajveer 6393 
    args.rechargeType = rechargeType
6048 rajveer 6394 
    args.deviceNumber = deviceNumber
6395 
    args.write(self._oprot)
6396 
    self._oprot.writeMessageEnd()
6397 
    self._oprot.trans.flush()
6398 
 
6399 
  def recv_getServiceProviderForDevice(self, ):
6400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6401 
    if mtype == TMessageType.EXCEPTION:
6402 
      x = TApplicationException()
6403 
      x.read(self._iprot)
6404 
      self._iprot.readMessageEnd()
6405 
      raise x
6406 
    result = getServiceProviderForDevice_result()
6407 
    result.read(self._iprot)
6408 
    self._iprot.readMessageEnd()
6409 
    if result.success is not None:
6410 
      return result.success
6411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6412 
 
6591 anupam.sin 6413 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6414 
    """
6415 
    Parameters:
6416 
     - rechargeType
6417 
     - deviceNumber
6307 anupam.sin 6418 
     - userSelectedProviderId
6591 anupam.sin 6419 
     - clientAddress
6269 rajveer 6420 
    """
6591 anupam.sin 6421 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6422 
    return self.recv_validateRecharge()
6423 
 
6591 anupam.sin 6424 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6425 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6426 
    args = validateRecharge_args()
6427 
    args.rechargeType = rechargeType
6428 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6429 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6430 
    args.clientAddress = clientAddress
6269 rajveer 6431 
    args.write(self._oprot)
6432 
    self._oprot.writeMessageEnd()
6433 
    self._oprot.trans.flush()
6434 
 
6435 
  def recv_validateRecharge(self, ):
6436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6437 
    if mtype == TMessageType.EXCEPTION:
6438 
      x = TApplicationException()
6439 
      x.read(self._iprot)
6440 
      self._iprot.readMessageEnd()
6441 
      raise x
6442 
    result = validateRecharge_result()
6443 
    result.read(self._iprot)
6444 
    self._iprot.readMessageEnd()
6445 
    if result.success is not None:
6446 
      return result.success
6447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6448 
 
6094 rajveer 6449 
  def getRechargeOrdersForDevice(self, deviceNumber):
6450 
    """
6451 
    Parameters:
6452 
     - deviceNumber
6453 
    """
6454 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6455 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6456 
 
6094 rajveer 6457 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6458 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6459 
    args = getRechargeOrdersForDevice_args()
6460 
    args.deviceNumber = deviceNumber
6461 
    args.write(self._oprot)
6462 
    self._oprot.writeMessageEnd()
6463 
    self._oprot.trans.flush()
6464 
 
6465 
  def recv_getRechargeOrdersForDevice(self, ):
6466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6467 
    if mtype == TMessageType.EXCEPTION:
6468 
      x = TApplicationException()
6469 
      x.read(self._iprot)
6470 
      self._iprot.readMessageEnd()
6471 
      raise x
6472 
    result = getRechargeOrdersForDevice_result()
6473 
    result.read(self._iprot)
6474 
    self._iprot.readMessageEnd()
6475 
    if result.success is not None:
6476 
      return result.success
6477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6478 
 
6479 
  def addAmountToWallet(self, userId, orderId, amount):
6480 
    """
6481 
    Parameters:
6482 
     - userId
6483 
     - orderId
6484 
     - amount
6485 
    """
6486 
    self.send_addAmountToWallet(userId, orderId, amount)
6487 
    self.recv_addAmountToWallet()
6488 
 
6489 
  def send_addAmountToWallet(self, userId, orderId, amount):
6490 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6491 
    args = addAmountToWallet_args()
6492 
    args.userId = userId
6493 
    args.orderId = orderId
6494 
    args.amount = amount
6495 
    args.write(self._oprot)
6496 
    self._oprot.writeMessageEnd()
6497 
    self._oprot.trans.flush()
6498 
 
6499 
  def recv_addAmountToWallet(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 = addAmountToWallet_result()
6507 
    result.read(self._iprot)
6508 
    self._iprot.readMessageEnd()
6509 
    return
6510 
 
6188 rajveer 6511 
  def getRechargeStatistics(self, ):
6512 
    self.send_getRechargeStatistics()
6513 
    return self.recv_getRechargeStatistics()
6514 
 
6515 
  def send_getRechargeStatistics(self, ):
6516 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6517 
    args = getRechargeStatistics_args()
6518 
    args.write(self._oprot)
6519 
    self._oprot.writeMessageEnd()
6520 
    self._oprot.trans.flush()
6521 
 
6522 
  def recv_getRechargeStatistics(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 = getRechargeStatistics_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, "getRechargeStatistics failed: unknown result");
6535 
 
6154 rajveer 6536 
  def getRechargeOrdersForStatus(self, status):
6537 
    """
6538 
    Parameters:
6539 
     - status
6540 
    """
6541 
    self.send_getRechargeOrdersForStatus(status)
6542 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6543 
 
6154 rajveer 6544 
  def send_getRechargeOrdersForStatus(self, status):
6545 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6546 
    args = getRechargeOrdersForStatus_args()
6547 
    args.status = status
6548 
    args.write(self._oprot)
6549 
    self._oprot.writeMessageEnd()
6550 
    self._oprot.trans.flush()
6551 
 
6552 
  def recv_getRechargeOrdersForStatus(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 = getRechargeOrdersForStatus_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, "getRechargeOrdersForStatus failed: unknown result");
6565 
 
6159 rajveer 6566 
  def getPlansForOperator(self, operatorId):
6567 
    """
6568 
    Parameters:
6569 
     - operatorId
6570 
    """
6571 
    self.send_getPlansForOperator(operatorId)
6572 
    return self.recv_getPlansForOperator()
6154 rajveer 6573 
 
6159 rajveer 6574 
  def send_getPlansForOperator(self, operatorId):
6575 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6576 
    args = getPlansForOperator_args()
6577 
    args.operatorId = operatorId
6578 
    args.write(self._oprot)
6579 
    self._oprot.writeMessageEnd()
6580 
    self._oprot.trans.flush()
6581 
 
6582 
  def recv_getPlansForOperator(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 = getPlansForOperator_result()
6590 
    result.read(self._iprot)
6591 
    self._iprot.readMessageEnd()
6592 
    if result.success is not None:
6593 
      return result.success
6594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6595 
 
6307 anupam.sin 6596 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6597 
    """
6598 
    Returns denominations for a given operator and circle
6159 rajveer 6599 
 
6289 anupam.sin 6600 
    Parameters:
6601 
     - operatorId
6307 anupam.sin 6602 
     - circleCode
6289 anupam.sin 6603 
     - denominationType
6604 
    """
6307 anupam.sin 6605 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6606 
    return self.recv_getRechargeDenominations()
6607 
 
6307 anupam.sin 6608 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6609 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6610 
    args = getRechargeDenominations_args()
6611 
    args.operatorId = operatorId
6307 anupam.sin 6612 
    args.circleCode = circleCode
6289 anupam.sin 6613 
    args.denominationType = denominationType
6614 
    args.write(self._oprot)
6615 
    self._oprot.writeMessageEnd()
6616 
    self._oprot.trans.flush()
6617 
 
6618 
  def recv_getRechargeDenominations(self, ):
6619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6620 
    if mtype == TMessageType.EXCEPTION:
6621 
      x = TApplicationException()
6622 
      x.read(self._iprot)
6623 
      self._iprot.readMessageEnd()
6624 
      raise x
6625 
    result = getRechargeDenominations_result()
6626 
    result.read(self._iprot)
6627 
    self._iprot.readMessageEnd()
6628 
    if result.success is not None:
6629 
      return result.success
6630 
    if result.ex is not None:
6631 
      raise result.ex
6632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6633 
 
6371 rajveer 6634 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6635 
    """
6636 
    Parameters:
6637 
     - operatorId
6638 
     - circleId
6639 
     - isAvailable
6640 
    """
6641 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6642 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6643 
 
6371 rajveer 6644 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6645 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6646 
    args = updateAvailabilityStatus_args()
6647 
    args.operatorId = operatorId
6648 
    args.circleId = circleId
6649 
    args.isAvailable = isAvailable
6650 
    args.write(self._oprot)
6651 
    self._oprot.writeMessageEnd()
6652 
    self._oprot.trans.flush()
6653 
 
6654 
  def recv_updateAvailabilityStatus(self, ):
6655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6656 
    if mtype == TMessageType.EXCEPTION:
6657 
      x = TApplicationException()
6658 
      x.read(self._iprot)
6659 
      self._iprot.readMessageEnd()
6660 
      raise x
6661 
    result = updateAvailabilityStatus_result()
6662 
    result.read(self._iprot)
6663 
    self._iprot.readMessageEnd()
6664 
    return
6665 
 
6389 rajveer 6666 
  def getAvailableEmiSchemes(self, ):
6667 
    self.send_getAvailableEmiSchemes()
6668 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6669 
 
6389 rajveer 6670 
  def send_getAvailableEmiSchemes(self, ):
6671 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6672 
    args = getAvailableEmiSchemes_args()
6673 
    args.write(self._oprot)
6674 
    self._oprot.writeMessageEnd()
6675 
    self._oprot.trans.flush()
6676 
 
6677 
  def recv_getAvailableEmiSchemes(self, ):
6678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6679 
    if mtype == TMessageType.EXCEPTION:
6680 
      x = TApplicationException()
6681 
      x.read(self._iprot)
6682 
      self._iprot.readMessageEnd()
6683 
      raise x
6684 
    result = getAvailableEmiSchemes_result()
6685 
    result.read(self._iprot)
6686 
    self._iprot.readMessageEnd()
6687 
    if result.success is not None:
6688 
      return result.success
6689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6690 
 
6691 
  def getMiscCharges(self, transactionId):
6692 
    """
6693 
    Parameters:
6694 
     - transactionId
6695 
    """
6696 
    self.send_getMiscCharges(transactionId)
6697 
    return self.recv_getMiscCharges()
6698 
 
6699 
  def send_getMiscCharges(self, transactionId):
6700 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6701 
    args = getMiscCharges_args()
6702 
    args.transactionId = transactionId
6703 
    args.write(self._oprot)
6704 
    self._oprot.writeMessageEnd()
6705 
    self._oprot.trans.flush()
6706 
 
6707 
  def recv_getMiscCharges(self, ):
6708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6709 
    if mtype == TMessageType.EXCEPTION:
6710 
      x = TApplicationException()
6711 
      x.read(self._iprot)
6712 
      self._iprot.readMessageEnd()
6713 
      raise x
6714 
    result = getMiscCharges_result()
6715 
    result.read(self._iprot)
6716 
    self._iprot.readMessageEnd()
6717 
    if result.success is not None:
6718 
      return result.success
6719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6720 
 
6507 anupam.sin 6721 
  def refundRechargeOrder(self, rechargeOrderId):
6722 
    """
6723 
    Parameters:
6724 
     - rechargeOrderId
6725 
    """
6726 
    self.send_refundRechargeOrder(rechargeOrderId)
6727 
    return self.recv_refundRechargeOrder()
6389 rajveer 6728 
 
6507 anupam.sin 6729 
  def send_refundRechargeOrder(self, rechargeOrderId):
6730 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6731 
    args = refundRechargeOrder_args()
6732 
    args.rechargeOrderId = rechargeOrderId
6733 
    args.write(self._oprot)
6734 
    self._oprot.writeMessageEnd()
6735 
    self._oprot.trans.flush()
6736 
 
6737 
  def recv_refundRechargeOrder(self, ):
6738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6739 
    if mtype == TMessageType.EXCEPTION:
6740 
      x = TApplicationException()
6741 
      x.read(self._iprot)
6742 
      self._iprot.readMessageEnd()
6743 
      raise x
6744 
    result = refundRechargeOrder_result()
6745 
    result.read(self._iprot)
6746 
    self._iprot.readMessageEnd()
6747 
    if result.success is not None:
6748 
      return result.success
6749 
    if result.ex is not None:
6750 
      raise result.ex
6751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6752 
 
6821 amar.kumar 6753 
  def getPhysicalOrders(self, fromDate, toDate):
6754 
    """
6755 
    Parameters:
6756 
     - fromDate
6757 
     - toDate
6758 
    """
6759 
    self.send_getPhysicalOrders(fromDate, toDate)
6760 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6761 
 
6821 amar.kumar 6762 
  def send_getPhysicalOrders(self, fromDate, toDate):
6763 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6764 
    args = getPhysicalOrders_args()
6765 
    args.fromDate = fromDate
6766 
    args.toDate = toDate
6767 
    args.write(self._oprot)
6768 
    self._oprot.writeMessageEnd()
6769 
    self._oprot.trans.flush()
6770 
 
6771 
  def recv_getPhysicalOrders(self, ):
6772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6773 
    if mtype == TMessageType.EXCEPTION:
6774 
      x = TApplicationException()
6775 
      x.read(self._iprot)
6776 
      self._iprot.readMessageEnd()
6777 
      raise x
6778 
    result = getPhysicalOrders_result()
6779 
    result.read(self._iprot)
6780 
    self._iprot.readMessageEnd()
6781 
    if result.success is not None:
6782 
      return result.success
6783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6784 
 
6906 rajveer 6785 
  def getDocument(self, docType, docSource):
6786 
    """
6787 
    Parameters:
6788 
     - docType
6789 
     - docSource
6790 
    """
6791 
    self.send_getDocument(docType, docSource)
6792 
    return self.recv_getDocument()
6821 amar.kumar 6793 
 
6906 rajveer 6794 
  def send_getDocument(self, docType, docSource):
6795 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6796 
    args = getDocument_args()
6797 
    args.docType = docType
6798 
    args.docSource = docSource
6799 
    args.write(self._oprot)
6800 
    self._oprot.writeMessageEnd()
6801 
    self._oprot.trans.flush()
6802 
 
6803 
  def recv_getDocument(self, ):
6804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6805 
    if mtype == TMessageType.EXCEPTION:
6806 
      x = TApplicationException()
6807 
      x.read(self._iprot)
6808 
      self._iprot.readMessageEnd()
6809 
      raise x
6810 
    result = getDocument_result()
6811 
    result.read(self._iprot)
6812 
    self._iprot.readMessageEnd()
6813 
    if result.success is not None:
6814 
      return result.success
6815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6816 
 
6985 anupam.sin 6817 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6818 
    """
6819 
    Parameters:
6820 
     - orderId
6821 
     - line1
6822 
     - line2
6823 
     - city
6824 
     - state
6825 
     - pin
6826 
    """
6827 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6828 
    return self.recv_changeShippingAddress()
6906 rajveer 6829 
 
6985 anupam.sin 6830 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6831 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6832 
    args = changeShippingAddress_args()
6833 
    args.orderId = orderId
6834 
    args.line1 = line1
6835 
    args.line2 = line2
6836 
    args.city = city
6837 
    args.state = state
6838 
    args.pin = pin
6839 
    args.write(self._oprot)
6840 
    self._oprot.writeMessageEnd()
6841 
    self._oprot.trans.flush()
6842 
 
6843 
  def recv_changeShippingAddress(self, ):
6844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6845 
    if mtype == TMessageType.EXCEPTION:
6846 
      x = TApplicationException()
6847 
      x.read(self._iprot)
6848 
      self._iprot.readMessageEnd()
6849 
      raise x
6850 
    result = changeShippingAddress_result()
6851 
    result.read(self._iprot)
6852 
    self._iprot.readMessageEnd()
6853 
    if result.success is not None:
6854 
      return result.success
6855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6856 
 
7075 rajveer 6857 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6858 
    """
6859 
    Parameters:
6860 
     - orderId
7075 rajveer 6861 
     - userId
6988 rajveer 6862 
    """
7075 rajveer 6863 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6864 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6865 
 
7075 rajveer 6866 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6867 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6868 
    args = retrieveInvoice_args()
6869 
    args.orderId = orderId
7075 rajveer 6870 
    args.userId = userId
6988 rajveer 6871 
    args.write(self._oprot)
6872 
    self._oprot.writeMessageEnd()
6873 
    self._oprot.trans.flush()
6874 
 
6875 
  def recv_retrieveInvoice(self, ):
6876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6877 
    if mtype == TMessageType.EXCEPTION:
6878 
      x = TApplicationException()
6879 
      x.read(self._iprot)
6880 
      self._iprot.readMessageEnd()
6881 
      raise x
6882 
    result = retrieveInvoice_result()
6883 
    result.read(self._iprot)
6884 
    self._iprot.readMessageEnd()
6885 
    if result.success is not None:
6886 
      return result.success
6887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6888 
 
7026 rajveer 6889 
  def receiveUpdatesForRedExpress(self, awbNumber):
6890 
    """
6891 
    Parameters:
6892 
     - awbNumber
6893 
    """
6894 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6895 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6896 
 
7026 rajveer 6897 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6898 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6899 
    args = receiveUpdatesForRedExpress_args()
6900 
    args.awbNumber = awbNumber
6901 
    args.write(self._oprot)
6902 
    self._oprot.writeMessageEnd()
6903 
    self._oprot.trans.flush()
6904 
 
6905 
  def recv_receiveUpdatesForRedExpress(self, ):
6906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6907 
    if mtype == TMessageType.EXCEPTION:
6908 
      x = TApplicationException()
6909 
      x.read(self._iprot)
6910 
      self._iprot.readMessageEnd()
6911 
      raise x
6912 
    result = receiveUpdatesForRedExpress_result()
6913 
    result.read(self._iprot)
6914 
    self._iprot.readMessageEnd()
6915 
    if result.success is not None:
6916 
      return result.success
6917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6918 
 
7073 anupam.sin 6919 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6920 
    """
6921 
    Parameters:
6922 
     - thriftRechargeTransaction
6923 
    """
6924 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6925 
    return self.recv_createRechargeTransaction()
7026 rajveer 6926 
 
7073 anupam.sin 6927 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6928 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6929 
    args = createRechargeTransaction_args()
6930 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6931 
    args.write(self._oprot)
6932 
    self._oprot.writeMessageEnd()
6933 
    self._oprot.trans.flush()
6934 
 
6935 
  def recv_createRechargeTransaction(self, ):
6936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6937 
    if mtype == TMessageType.EXCEPTION:
6938 
      x = TApplicationException()
6939 
      x.read(self._iprot)
6940 
      self._iprot.readMessageEnd()
6941 
      raise x
6942 
    result = createRechargeTransaction_result()
6943 
    result.read(self._iprot)
6944 
    self._iprot.readMessageEnd()
6945 
    if result.success is not None:
6946 
      return result.success
6947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6948 
 
7085 rajveer 6949 
  def getRechargeTransactions(self, storeId):
6950 
    """
6951 
    Parameters:
6952 
     - storeId
6953 
    """
6954 
    self.send_getRechargeTransactions(storeId)
6955 
    return self.recv_getRechargeTransactions()
6956 
 
6957 
  def send_getRechargeTransactions(self, storeId):
6958 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6959 
    args = getRechargeTransactions_args()
6960 
    args.storeId = storeId
6961 
    args.write(self._oprot)
6962 
    self._oprot.writeMessageEnd()
6963 
    self._oprot.trans.flush()
6964 
 
6965 
  def recv_getRechargeTransactions(self, ):
6966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6967 
    if mtype == TMessageType.EXCEPTION:
6968 
      x = TApplicationException()
6969 
      x.read(self._iprot)
6970 
      self._iprot.readMessageEnd()
6971 
      raise x
6972 
    result = getRechargeTransactions_result()
6973 
    result.read(self._iprot)
6974 
    self._iprot.readMessageEnd()
6975 
    if result.success is not None:
6976 
      return result.success
6977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6978 
 
7151 amit.gupta 6979 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
6980 
    """
6981 
    Parameters:
6982 
     - storeId
6983 
     - startDate
6984 
     - endDate
6985 
     - status
6986 
    """
6987 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
6988 
    return self.recv_getRechargeTrans()
6989 
 
6990 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
6991 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
6992 
    args = getRechargeTrans_args()
6993 
    args.storeId = storeId
6994 
    args.startDate = startDate
6995 
    args.endDate = endDate
6996 
    args.status = status
6997 
    args.write(self._oprot)
6998 
    self._oprot.writeMessageEnd()
6999 
    self._oprot.trans.flush()
7000 
 
7001 
  def recv_getRechargeTrans(self, ):
7002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7003 
    if mtype == TMessageType.EXCEPTION:
7004 
      x = TApplicationException()
7005 
      x.read(self._iprot)
7006 
      self._iprot.readMessageEnd()
7007 
      raise x
7008 
    result = getRechargeTrans_result()
7009 
    result.read(self._iprot)
7010 
    self._iprot.readMessageEnd()
7011 
    if result.success is not None:
7012 
      return result.success
7013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
7014 
 
7080 anupam.sin 7015 
  def getRechargeTransaction(self, rechargeId):
7016 
    """
7017 
    Parameters:
7018 
     - rechargeId
7019 
    """
7020 
    self.send_getRechargeTransaction(rechargeId)
7021 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 7022 
 
7080 anupam.sin 7023 
  def send_getRechargeTransaction(self, rechargeId):
7024 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
7025 
    args = getRechargeTransaction_args()
7026 
    args.rechargeId = rechargeId
7027 
    args.write(self._oprot)
7028 
    self._oprot.writeMessageEnd()
7029 
    self._oprot.trans.flush()
7030 
 
7031 
  def recv_getRechargeTransaction(self, ):
7032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7033 
    if mtype == TMessageType.EXCEPTION:
7034 
      x = TApplicationException()
7035 
      x.read(self._iprot)
7036 
      self._iprot.readMessageEnd()
7037 
      raise x
7038 
    result = getRechargeTransaction_result()
7039 
    result.read(self._iprot)
7040 
    self._iprot.readMessageEnd()
7041 
    if result.success is not None:
7042 
      return result.success
7043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
7044 
 
7045 
  def getFRCs(self, circleId, operatorId):
7046 
    """
7047 
    Parameters:
7048 
     - circleId
7049 
     - operatorId
7050 
    """
7051 
    self.send_getFRCs(circleId, operatorId)
7052 
    return self.recv_getFRCs()
7053 
 
7054 
  def send_getFRCs(self, circleId, operatorId):
7055 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
7056 
    args = getFRCs_args()
7057 
    args.circleId = circleId
7058 
    args.operatorId = operatorId
7059 
    args.write(self._oprot)
7060 
    self._oprot.writeMessageEnd()
7061 
    self._oprot.trans.flush()
7062 
 
7063 
  def recv_getFRCs(self, ):
7064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7065 
    if mtype == TMessageType.EXCEPTION:
7066 
      x = TApplicationException()
7067 
      x.read(self._iprot)
7068 
      self._iprot.readMessageEnd()
7069 
      raise x
7070 
    result = getFRCs_result()
7071 
    result.read(self._iprot)
7072 
    self._iprot.readMessageEnd()
7073 
    if result.success is not None:
7074 
      return result.success
7075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
7076 
 
7096 anupam.sin 7077 
  def getHotspotStore(self, id, hotspotid):
7078 
    """
7079 
    Parameters:
7080 
     - id
7081 
     - hotspotid
7082 
    """
7083 
    self.send_getHotspotStore(id, hotspotid)
7084 
    return self.recv_getHotspotStore()
7080 anupam.sin 7085 
 
7096 anupam.sin 7086 
  def send_getHotspotStore(self, id, hotspotid):
7087 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
7088 
    args = getHotspotStore_args()
7089 
    args.id = id
7090 
    args.hotspotid = hotspotid
7091 
    args.write(self._oprot)
7092 
    self._oprot.writeMessageEnd()
7093 
    self._oprot.trans.flush()
7094 
 
7095 
  def recv_getHotspotStore(self, ):
7096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7097 
    if mtype == TMessageType.EXCEPTION:
7098 
      x = TApplicationException()
7099 
      x.read(self._iprot)
7100 
      self._iprot.readMessageEnd()
7101 
      raise x
7102 
    result = getHotspotStore_result()
7103 
    result.read(self._iprot)
7104 
    self._iprot.readMessageEnd()
7105 
    if result.success is not None:
7106 
      return result.success
7107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
7108 
 
7109 
  def getTelecomCircle(self, id, code):
7110 
    """
7111 
    Parameters:
7112 
     - id
7113 
     - code
7114 
    """
7115 
    self.send_getTelecomCircle(id, code)
7116 
    return self.recv_getTelecomCircle()
7117 
 
7118 
  def send_getTelecomCircle(self, id, code):
7119 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7120 
    args = getTelecomCircle_args()
7121 
    args.id = id
7122 
    args.code = code
7123 
    args.write(self._oprot)
7124 
    self._oprot.writeMessageEnd()
7125 
    self._oprot.trans.flush()
7126 
 
7127 
  def recv_getTelecomCircle(self, ):
7128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7129 
    if mtype == TMessageType.EXCEPTION:
7130 
      x = TApplicationException()
7131 
      x.read(self._iprot)
7132 
      self._iprot.readMessageEnd()
7133 
      raise x
7134 
    result = getTelecomCircle_result()
7135 
    result.read(self._iprot)
7136 
    self._iprot.readMessageEnd()
7137 
    if result.success is not None:
7138 
      return result.success
7139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
7140 
 
7109 anupam.sin 7141 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7142 
    """
7143 
    Parameters:
7144 
     - rechargeId
7145 
    """
7146 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7147 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7148 
 
7109 anupam.sin 7149 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7150 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7151 
    args = retrieveHotspotRechargeInvoice_args()
7152 
    args.rechargeId = rechargeId
7153 
    args.write(self._oprot)
7154 
    self._oprot.writeMessageEnd()
7155 
    self._oprot.trans.flush()
7156 
 
7157 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7159 
    if mtype == TMessageType.EXCEPTION:
7160 
      x = TApplicationException()
7161 
      x.read(self._iprot)
7162 
      self._iprot.readMessageEnd()
7163 
      raise x
7164 
    result = retrieveHotspotRechargeInvoice_result()
7165 
    result.read(self._iprot)
7166 
    self._iprot.readMessageEnd()
7167 
    if result.success is not None:
7168 
      return result.success
7169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7170 
 
7190 amar.kumar 7171 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
7172 
    """
7173 
    Parameters:
7174 
     - orderId
7175 
     - splitReason
7176 
     - shippingDate
7177 
    """
7178 
    self.send_splitFreebieOrder(orderId, splitReason, shippingDate)
7179 
    return self.recv_splitFreebieOrder()
7180 
 
7181 
  def send_splitFreebieOrder(self, orderId, splitReason, shippingDate):
7182 
    self._oprot.writeMessageBegin('splitFreebieOrder', TMessageType.CALL, self._seqid)
7183 
    args = splitFreebieOrder_args()
7184 
    args.orderId = orderId
7185 
    args.splitReason = splitReason
7186 
    args.shippingDate = shippingDate
7187 
    args.write(self._oprot)
7188 
    self._oprot.writeMessageEnd()
7189 
    self._oprot.trans.flush()
7190 
 
7191 
  def recv_splitFreebieOrder(self, ):
7192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7193 
    if mtype == TMessageType.EXCEPTION:
7194 
      x = TApplicationException()
7195 
      x.read(self._iprot)
7196 
      self._iprot.readMessageEnd()
7197 
      raise x
7198 
    result = splitFreebieOrder_result()
7199 
    result.read(self._iprot)
7200 
    self._iprot.readMessageEnd()
7201 
    if result.success is not None:
7202 
      return result.success
7203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "splitFreebieOrder failed: unknown result");
7204 
 
7172 anupam.sin 7205 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7206 
    """
7207 
    Parameters:
7208 
     - number
7172 anupam.sin 7209 
     - storeId
7169 anupam.sin 7210 
    """
7172 anupam.sin 7211 
    self.send_getRechargeTransactionsByNumber(number, storeId)
7169 anupam.sin 7212 
    return self.recv_getRechargeTransactionsByNumber()
7109 anupam.sin 7213 
 
7172 anupam.sin 7214 
  def send_getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7215 
    self._oprot.writeMessageBegin('getRechargeTransactionsByNumber', TMessageType.CALL, self._seqid)
7216 
    args = getRechargeTransactionsByNumber_args()
7217 
    args.number = number
7172 anupam.sin 7218 
    args.storeId = storeId
7169 anupam.sin 7219 
    args.write(self._oprot)
7220 
    self._oprot.writeMessageEnd()
7221 
    self._oprot.trans.flush()
7222 
 
7223 
  def recv_getRechargeTransactionsByNumber(self, ):
7224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7225 
    if mtype == TMessageType.EXCEPTION:
7226 
      x = TApplicationException()
7227 
      x.read(self._iprot)
7228 
      self._iprot.readMessageEnd()
7229 
      raise x
7230 
    result = getRechargeTransactionsByNumber_result()
7231 
    result.read(self._iprot)
7232 
    self._iprot.readMessageEnd()
7233 
    if result.success is not None:
7234 
      return result.success
7235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactionsByNumber failed: unknown result");
7236 
 
7237 
  def updateHotspotStorePassword(self, storeId, password):
7238 
    """
7239 
    Parameters:
7240 
     - storeId
7241 
     - password
7242 
    """
7243 
    self.send_updateHotspotStorePassword(storeId, password)
7244 
    return self.recv_updateHotspotStorePassword()
7245 
 
7246 
  def send_updateHotspotStorePassword(self, storeId, password):
7247 
    self._oprot.writeMessageBegin('updateHotspotStorePassword', TMessageType.CALL, self._seqid)
7248 
    args = updateHotspotStorePassword_args()
7249 
    args.storeId = storeId
7250 
    args.password = password
7251 
    args.write(self._oprot)
7252 
    self._oprot.writeMessageEnd()
7253 
    self._oprot.trans.flush()
7254 
 
7255 
  def recv_updateHotspotStorePassword(self, ):
7256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7257 
    if mtype == TMessageType.EXCEPTION:
7258 
      x = TApplicationException()
7259 
      x.read(self._iprot)
7260 
      self._iprot.readMessageEnd()
7261 
      raise x
7262 
    result = updateHotspotStorePassword_result()
7263 
    result.read(self._iprot)
7264 
    self._iprot.readMessageEnd()
7265 
    if result.success is not None:
7266 
      return result.success
7267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateHotspotStorePassword failed: unknown result");
7268 
 
7285 rajveer 7269 
  def topupCompanyWallet(self, companyId, amount):
7263 anupam.sin 7270 
    """
7271 
    Parameters:
7285 rajveer 7272 
     - companyId
7273 
     - amount
7263 anupam.sin 7274 
    """
7285 rajveer 7275 
    self.send_topupCompanyWallet(companyId, amount)
7276 
    return self.recv_topupCompanyWallet()
7169 anupam.sin 7277 
 
7285 rajveer 7278 
  def send_topupCompanyWallet(self, companyId, amount):
7279 
    self._oprot.writeMessageBegin('topupCompanyWallet', TMessageType.CALL, self._seqid)
7280 
    args = topupCompanyWallet_args()
7281 
    args.companyId = companyId
7282 
    args.amount = amount
7263 anupam.sin 7283 
    args.write(self._oprot)
7284 
    self._oprot.writeMessageEnd()
7285 
    self._oprot.trans.flush()
7286 
 
7285 rajveer 7287 
  def recv_topupCompanyWallet(self, ):
7263 anupam.sin 7288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7289 
    if mtype == TMessageType.EXCEPTION:
7290 
      x = TApplicationException()
7291 
      x.read(self._iprot)
7292 
      self._iprot.readMessageEnd()
7293 
      raise x
7285 rajveer 7294 
    result = topupCompanyWallet_result()
7263 anupam.sin 7295 
    result.read(self._iprot)
7296 
    self._iprot.readMessageEnd()
7297 
    if result.success is not None:
7298 
      return result.success
7285 rajveer 7299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "topupCompanyWallet failed: unknown result");
7263 anupam.sin 7300 
 
7285 rajveer 7301 
  def getWalletBalanceForCompany(self, companyId):
7302 
    """
7303 
    Parameters:
7304 
     - companyId
7305 
    """
7306 
    self.send_getWalletBalanceForCompany(companyId)
7307 
    return self.recv_getWalletBalanceForCompany()
7263 anupam.sin 7308 
 
7285 rajveer 7309 
  def send_getWalletBalanceForCompany(self, companyId):
7310 
    self._oprot.writeMessageBegin('getWalletBalanceForCompany', TMessageType.CALL, self._seqid)
7311 
    args = getWalletBalanceForCompany_args()
7312 
    args.companyId = companyId
7267 anupam.sin 7313 
    args.write(self._oprot)
7314 
    self._oprot.writeMessageEnd()
7315 
    self._oprot.trans.flush()
7316 
 
7285 rajveer 7317 
  def recv_getWalletBalanceForCompany(self, ):
7267 anupam.sin 7318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7319 
    if mtype == TMessageType.EXCEPTION:
7320 
      x = TApplicationException()
7321 
      x.read(self._iprot)
7322 
      self._iprot.readMessageEnd()
7323 
      raise x
7285 rajveer 7324 
    result = getWalletBalanceForCompany_result()
7267 anupam.sin 7325 
    result.read(self._iprot)
7326 
    self._iprot.readMessageEnd()
7327 
    if result.success is not None:
7328 
      return result.success
7285 rajveer 7329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWalletBalanceForCompany failed: unknown result");
7267 anupam.sin 7330 
 
7285 rajveer 7331 
  def getSourceDetail(self, source):
7267 anupam.sin 7332 
    """
7333 
    Parameters:
7285 rajveer 7334 
     - source
7267 anupam.sin 7335 
    """
7285 rajveer 7336 
    self.send_getSourceDetail(source)
7337 
    return self.recv_getSourceDetail()
7267 anupam.sin 7338 
 
7285 rajveer 7339 
  def send_getSourceDetail(self, source):
7340 
    self._oprot.writeMessageBegin('getSourceDetail', TMessageType.CALL, self._seqid)
7341 
    args = getSourceDetail_args()
7342 
    args.source = source
7267 anupam.sin 7343 
    args.write(self._oprot)
7344 
    self._oprot.writeMessageEnd()
7345 
    self._oprot.trans.flush()
7346 
 
7285 rajveer 7347 
  def recv_getSourceDetail(self, ):
7267 anupam.sin 7348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7349 
    if mtype == TMessageType.EXCEPTION:
7350 
      x = TApplicationException()
7351 
      x.read(self._iprot)
7352 
      self._iprot.readMessageEnd()
7353 
      raise x
7285 rajveer 7354 
    result = getSourceDetail_result()
7267 anupam.sin 7355 
    result.read(self._iprot)
7356 
    self._iprot.readMessageEnd()
7357 
    if result.success is not None:
7358 
      return result.success
7285 rajveer 7359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSourceDetail failed: unknown result");
7267 anupam.sin 7360 
 
7308 rajveer 7361 
  def getAllCircles(self, ):
7362 
    self.send_getAllCircles()
7363 
    return self.recv_getAllCircles()
7267 anupam.sin 7364 
 
7308 rajveer 7365 
  def send_getAllCircles(self, ):
7366 
    self._oprot.writeMessageBegin('getAllCircles', TMessageType.CALL, self._seqid)
7367 
    args = getAllCircles_args()
7368 
    args.write(self._oprot)
7369 
    self._oprot.writeMessageEnd()
7370 
    self._oprot.trans.flush()
7371 
 
7372 
  def recv_getAllCircles(self, ):
7373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7374 
    if mtype == TMessageType.EXCEPTION:
7375 
      x = TApplicationException()
7376 
      x.read(self._iprot)
7377 
      self._iprot.readMessageEnd()
7378 
      raise x
7379 
    result = getAllCircles_result()
7380 
    result.read(self._iprot)
7381 
    self._iprot.readMessageEnd()
7382 
    if result.success is not None:
7383 
      return result.success
7384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCircles failed: unknown result");
7385 
 
7386 
  def deleteFrcs(self, frcIdsToDelete):
7387 
    """
7388 
    Parameters:
7389 
     - frcIdsToDelete
7390 
    """
7391 
    self.send_deleteFrcs(frcIdsToDelete)
7392 
    return self.recv_deleteFrcs()
7393 
 
7394 
  def send_deleteFrcs(self, frcIdsToDelete):
7395 
    self._oprot.writeMessageBegin('deleteFrcs', TMessageType.CALL, self._seqid)
7396 
    args = deleteFrcs_args()
7397 
    args.frcIdsToDelete = frcIdsToDelete
7398 
    args.write(self._oprot)
7399 
    self._oprot.writeMessageEnd()
7400 
    self._oprot.trans.flush()
7401 
 
7402 
  def recv_deleteFrcs(self, ):
7403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7404 
    if mtype == TMessageType.EXCEPTION:
7405 
      x = TApplicationException()
7406 
      x.read(self._iprot)
7407 
      self._iprot.readMessageEnd()
7408 
      raise x
7409 
    result = deleteFrcs_result()
7410 
    result.read(self._iprot)
7411 
    self._iprot.readMessageEnd()
7412 
    if result.success is not None:
7413 
      return result.success
7414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteFrcs failed: unknown result");
7415 
 
7311 kshitij.so 7416 
  def addAmazonOrder(self, amazonOrder):
7417 
    """
7418 
    Parameters:
7419 
     - amazonOrder
7420 
    """
7421 
    self.send_addAmazonOrder(amazonOrder)
7422 
    self.recv_addAmazonOrder()
7308 rajveer 7423 
 
7311 kshitij.so 7424 
  def send_addAmazonOrder(self, amazonOrder):
7425 
    self._oprot.writeMessageBegin('addAmazonOrder', TMessageType.CALL, self._seqid)
7426 
    args = addAmazonOrder_args()
7427 
    args.amazonOrder = amazonOrder
7428 
    args.write(self._oprot)
7429 
    self._oprot.writeMessageEnd()
7430 
    self._oprot.trans.flush()
7431 
 
7432 
  def recv_addAmazonOrder(self, ):
7433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7434 
    if mtype == TMessageType.EXCEPTION:
7435 
      x = TApplicationException()
7436 
      x.read(self._iprot)
7437 
      self._iprot.readMessageEnd()
7438 
      raise x
7439 
    result = addAmazonOrder_result()
7440 
    result.read(self._iprot)
7441 
    self._iprot.readMessageEnd()
7442 
    return
7443 
 
7322 vikram.rag 7444 
  def updateAmazonOrderStatus(self, orderId, status):
7311 kshitij.so 7445 
    """
7446 
    Parameters:
7447 
     - orderId
7448 
     - status
7449 
    """
7322 vikram.rag 7450 
    self.send_updateAmazonOrderStatus(orderId, status)
7451 
    return self.recv_updateAmazonOrderStatus()
7311 kshitij.so 7452 
 
7322 vikram.rag 7453 
  def send_updateAmazonOrderStatus(self, orderId, status):
7454 
    self._oprot.writeMessageBegin('updateAmazonOrderStatus', TMessageType.CALL, self._seqid)
7455 
    args = updateAmazonOrderStatus_args()
7311 kshitij.so 7456 
    args.orderId = orderId
7457 
    args.status = status
7458 
    args.write(self._oprot)
7459 
    self._oprot.writeMessageEnd()
7460 
    self._oprot.trans.flush()
7461 
 
7322 vikram.rag 7462 
  def recv_updateAmazonOrderStatus(self, ):
7311 kshitij.so 7463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7464 
    if mtype == TMessageType.EXCEPTION:
7465 
      x = TApplicationException()
7466 
      x.read(self._iprot)
7467 
      self._iprot.readMessageEnd()
7468 
      raise x
7322 vikram.rag 7469 
    result = updateAmazonOrderStatus_result()
7311 kshitij.so 7470 
    result.read(self._iprot)
7471 
    self._iprot.readMessageEnd()
7472 
    if result.success is not None:
7473 
      return result.success
7322 vikram.rag 7474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonOrderStatus failed: unknown result");
7311 kshitij.so 7475 
 
7476 
  def getAmazonOrdersShipped(self, interval):
7477 
    """
7478 
    Parameters:
7479 
     - interval
7480 
    """
7481 
    self.send_getAmazonOrdersShipped(interval)
7482 
    return self.recv_getAmazonOrdersShipped()
7483 
 
7484 
  def send_getAmazonOrdersShipped(self, interval):
7485 
    self._oprot.writeMessageBegin('getAmazonOrdersShipped', TMessageType.CALL, self._seqid)
7486 
    args = getAmazonOrdersShipped_args()
7487 
    args.interval = interval
7488 
    args.write(self._oprot)
7489 
    self._oprot.writeMessageEnd()
7490 
    self._oprot.trans.flush()
7491 
 
7492 
  def recv_getAmazonOrdersShipped(self, ):
7493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7494 
    if mtype == TMessageType.EXCEPTION:
7495 
      x = TApplicationException()
7496 
      x.read(self._iprot)
7497 
      self._iprot.readMessageEnd()
7498 
      raise x
7499 
    result = getAmazonOrdersShipped_result()
7500 
    result.read(self._iprot)
7501 
    self._iprot.readMessageEnd()
7502 
    if result.success is not None:
7503 
      return result.success
7504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOrdersShipped failed: unknown result");
7505 
 
7506 
  def getAmazonOrdersCancelled(self, interval):
7507 
    """
7508 
    Parameters:
7509 
     - interval
7510 
    """
7511 
    self.send_getAmazonOrdersCancelled(interval)
7512 
    return self.recv_getAmazonOrdersCancelled()
7513 
 
7514 
  def send_getAmazonOrdersCancelled(self, interval):
7515 
    self._oprot.writeMessageBegin('getAmazonOrdersCancelled', TMessageType.CALL, self._seqid)
7516 
    args = getAmazonOrdersCancelled_args()
7517 
    args.interval = interval
7518 
    args.write(self._oprot)
7519 
    self._oprot.writeMessageEnd()
7520 
    self._oprot.trans.flush()
7521 
 
7522 
  def recv_getAmazonOrdersCancelled(self, ):
7523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7524 
    if mtype == TMessageType.EXCEPTION:
7525 
      x = TApplicationException()
7526 
      x.read(self._iprot)
7527 
      self._iprot.readMessageEnd()
7528 
      raise x
7529 
    result = getAmazonOrdersCancelled_result()
7530 
    result.read(self._iprot)
7531 
    self._iprot.readMessageEnd()
7532 
    if result.success is not None:
7533 
      return result.success
7534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOrdersCancelled failed: unknown result");
7535 
 
7322 vikram.rag 7536 
  def getAmazonOrder(self, orderId):
7537 
    """
7538 
    Parameters:
7539 
     - orderId
7540 
    """
7541 
    self.send_getAmazonOrder(orderId)
7542 
    return self.recv_getAmazonOrder()
7311 kshitij.so 7543 
 
7322 vikram.rag 7544 
  def send_getAmazonOrder(self, orderId):
7545 
    self._oprot.writeMessageBegin('getAmazonOrder', TMessageType.CALL, self._seqid)
7546 
    args = getAmazonOrder_args()
7547 
    args.orderId = orderId
7548 
    args.write(self._oprot)
7549 
    self._oprot.writeMessageEnd()
7550 
    self._oprot.trans.flush()
7551 
 
7552 
  def recv_getAmazonOrder(self, ):
7553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7554 
    if mtype == TMessageType.EXCEPTION:
7555 
      x = TApplicationException()
7556 
      x.read(self._iprot)
7557 
      self._iprot.readMessageEnd()
7558 
      raise x
7559 
    result = getAmazonOrder_result()
7560 
    result.read(self._iprot)
7561 
    self._iprot.readMessageEnd()
7562 
    if result.success is not None:
7563 
      return result.success
7564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOrder failed: unknown result");
7565 
 
7566 
 
3376 rajveer 7567 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7568 
  def __init__(self, handler):
3376 rajveer 7569 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7570 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7571 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7572 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7573 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7574 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7575 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7576 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7577 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7578 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7579 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7580 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7581 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7582 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7583 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7584 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7585 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7586 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7587 
    self._processMap["createOrder"] = Processor.process_createOrder
7588 
    self._processMap["getOrder"] = Processor.process_getOrder
7589 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7590 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7591 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7592 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7593 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7594 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7595 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7596 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7597 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7598 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7599 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7600 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7601 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7602 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7603 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7604 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7605 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7606 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7607 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7608 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7609 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7610 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7611 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7612 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7613 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7614 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7615 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7616 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7617 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7618 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7619 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7620 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7621 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7622 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7623 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7624 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7625 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7626 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7627 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7628 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7629 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7630 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7631 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7632 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7633 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7634 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7635 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7636 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7637 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7638 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7639 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7640 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7641 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7642 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7643 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7644 
    self._processMap["changeItem"] = Processor.process_changeItem
7645 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7646 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7647 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7648 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7649 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7650 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7651 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7652 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7653 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7654 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7655 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7656 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7657 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7658 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7659 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7660 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7661 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7662 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7663 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7664 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7665 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7666 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7667 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7668 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7669 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7670 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7671 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7672 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7673 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7674 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7675 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7676 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7677 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7678 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7679 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7680 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7681 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7682 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7683 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7684 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7685 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7686 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7687 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7688 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7689 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7690 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7691 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7692 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7693 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7694 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7695 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7696 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7697 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7698 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7699 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7700 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7701 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7702 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7703 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7704 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7705 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7706 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7707 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7708 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7709 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7710 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7711 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7712 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7713 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7714 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7715 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7716 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7717 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7718 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7719 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7720 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7721 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7722 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7723 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7724 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7725 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7726 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7727 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7728 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7729 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7730 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
7190 amar.kumar 7731 
    self._processMap["splitFreebieOrder"] = Processor.process_splitFreebieOrder
7169 anupam.sin 7732 
    self._processMap["getRechargeTransactionsByNumber"] = Processor.process_getRechargeTransactionsByNumber
7733 
    self._processMap["updateHotspotStorePassword"] = Processor.process_updateHotspotStorePassword
7285 rajveer 7734 
    self._processMap["topupCompanyWallet"] = Processor.process_topupCompanyWallet
7735 
    self._processMap["getWalletBalanceForCompany"] = Processor.process_getWalletBalanceForCompany
7263 anupam.sin 7736 
    self._processMap["getSourceDetail"] = Processor.process_getSourceDetail
7308 rajveer 7737 
    self._processMap["getAllCircles"] = Processor.process_getAllCircles
7738 
    self._processMap["deleteFrcs"] = Processor.process_deleteFrcs
7311 kshitij.so 7739 
    self._processMap["addAmazonOrder"] = Processor.process_addAmazonOrder
7322 vikram.rag 7740 
    self._processMap["updateAmazonOrderStatus"] = Processor.process_updateAmazonOrderStatus
7311 kshitij.so 7741 
    self._processMap["getAmazonOrdersShipped"] = Processor.process_getAmazonOrdersShipped
7742 
    self._processMap["getAmazonOrdersCancelled"] = Processor.process_getAmazonOrdersCancelled
7322 vikram.rag 7743 
    self._processMap["getAmazonOrder"] = Processor.process_getAmazonOrder
94 ashish 7744 
 
7745 
  def process(self, iprot, oprot):
7746 
    (name, type, seqid) = iprot.readMessageBegin()
7747 
    if name not in self._processMap:
7748 
      iprot.skip(TType.STRUCT)
7749 
      iprot.readMessageEnd()
7750 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7751 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7752 
      x.write(oprot)
7753 
      oprot.writeMessageEnd()
7754 
      oprot.trans.flush()
7755 
      return
7756 
    else:
7757 
      self._processMap[name](self, seqid, iprot, oprot)
7758 
    return True
7759 
 
7760 
  def process_createTransaction(self, seqid, iprot, oprot):
7761 
    args = createTransaction_args()
7762 
    args.read(iprot)
7763 
    iprot.readMessageEnd()
7764 
    result = createTransaction_result()
7765 
    try:
132 ashish 7766 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7767 
    except TransactionServiceException, ex:
7768 
      result.ex = ex
7769 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7770 
    result.write(oprot)
7771 
    oprot.writeMessageEnd()
7772 
    oprot.trans.flush()
7773 
 
7774 
  def process_getTransaction(self, seqid, iprot, oprot):
7775 
    args = getTransaction_args()
7776 
    args.read(iprot)
7777 
    iprot.readMessageEnd()
7778 
    result = getTransaction_result()
7779 
    try:
7780 
      result.success = self._handler.getTransaction(args.id)
7781 
    except TransactionServiceException, ex:
7782 
      result.ex = ex
7783 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7784 
    result.write(oprot)
7785 
    oprot.writeMessageEnd()
7786 
    oprot.trans.flush()
7787 
 
7788 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7789 
    args = getTransactionsForCustomer_args()
7790 
    args.read(iprot)
7791 
    iprot.readMessageEnd()
7792 
    result = getTransactionsForCustomer_result()
7793 
    try:
7794 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7795 
    except TransactionServiceException, ex:
7796 
      result.ex = ex
7797 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7798 
    result.write(oprot)
7799 
    oprot.writeMessageEnd()
7800 
    oprot.trans.flush()
7801 
 
132 ashish 7802 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7803 
    args = getTransactionsForShoppingCartId_args()
7804 
    args.read(iprot)
7805 
    iprot.readMessageEnd()
7806 
    result = getTransactionsForShoppingCartId_result()
7807 
    try:
7808 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7809 
    except TransactionServiceException, ex:
7810 
      result.ex = ex
7811 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7812 
    result.write(oprot)
7813 
    oprot.writeMessageEnd()
7814 
    oprot.trans.flush()
7815 
 
94 ashish 7816 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7817 
    args = getTransactionStatus_args()
7818 
    args.read(iprot)
7819 
    iprot.readMessageEnd()
7820 
    result = getTransactionStatus_result()
7821 
    try:
7822 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7823 
    except TransactionServiceException, ex:
7824 
      result.ex = ex
7825 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7826 
    result.write(oprot)
7827 
    oprot.writeMessageEnd()
7828 
    oprot.trans.flush()
7829 
 
7830 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7831 
    args = changeTransactionStatus_args()
7832 
    args.read(iprot)
7833 
    iprot.readMessageEnd()
7834 
    result = changeTransactionStatus_result()
7835 
    try:
7293 anupam.sin 7836 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType, args.source)
94 ashish 7837 
    except TransactionServiceException, ex:
7838 
      result.ex = ex
7839 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7840 
    result.write(oprot)
7841 
    oprot.writeMessageEnd()
7842 
    oprot.trans.flush()
7843 
 
1398 varun.gupt 7844 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7845 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7846 
    args.read(iprot)
7847 
    iprot.readMessageEnd()
1398 varun.gupt 7848 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7849 
    try:
1398 varun.gupt 7850 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7851 
    except TransactionServiceException, ex:
7852 
      result.ex = ex
1398 varun.gupt 7853 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7854 
    result.write(oprot)
7855 
    oprot.writeMessageEnd()
7856 
    oprot.trans.flush()
7857 
 
483 rajveer 7858 
  def process_getAllOrders(self, seqid, iprot, oprot):
7859 
    args = getAllOrders_args()
94 ashish 7860 
    args.read(iprot)
7861 
    iprot.readMessageEnd()
483 rajveer 7862 
    result = getAllOrders_result()
94 ashish 7863 
    try:
4801 anupam.sin 7864 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7865 
    except TransactionServiceException, ex:
7866 
      result.ex = ex
483 rajveer 7867 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7868 
    result.write(oprot)
7869 
    oprot.writeMessageEnd()
7870 
    oprot.trans.flush()
7871 
 
4133 chandransh 7872 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7873 
    args = getOrdersInBatch_args()
7874 
    args.read(iprot)
7875 
    iprot.readMessageEnd()
7876 
    result = getOrdersInBatch_result()
7877 
    try:
7878 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7879 
    except TransactionServiceException, ex:
7880 
      result.ex = ex
7881 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7882 
    result.write(oprot)
7883 
    oprot.writeMessageEnd()
7884 
    oprot.trans.flush()
7885 
 
7886 
  def process_getOrderCount(self, seqid, iprot, oprot):
7887 
    args = getOrderCount_args()
7888 
    args.read(iprot)
7889 
    iprot.readMessageEnd()
7890 
    result = getOrderCount_result()
7891 
    try:
7892 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7893 
    except TransactionServiceException, ex:
7894 
      result.ex = ex
7895 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7896 
    result.write(oprot)
7897 
    oprot.writeMessageEnd()
7898 
    oprot.trans.flush()
7899 
 
999 varun.gupt 7900 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7901 
    args = getOrdersByBillingDate_args()
7902 
    args.read(iprot)
7903 
    iprot.readMessageEnd()
7904 
    result = getOrdersByBillingDate_result()
7905 
    try:
7906 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7907 
    except TransactionServiceException, ex:
7908 
      result.ex = ex
7909 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7910 
    result.write(oprot)
7911 
    oprot.writeMessageEnd()
7912 
    oprot.trans.flush()
7913 
 
3427 chandransh 7914 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7915 
    args = getOrdersByShippingDate_args()
7916 
    args.read(iprot)
7917 
    iprot.readMessageEnd()
7918 
    result = getOrdersByShippingDate_result()
7919 
    try:
3451 chandransh 7920 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7921 
    except TransactionServiceException, ex:
7922 
      result.ex = ex
7923 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7924 
    result.write(oprot)
7925 
    oprot.writeMessageEnd()
7926 
    oprot.trans.flush()
7927 
 
1382 varun.gupt 7928 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7929 
    args = getReturnableOrdersForCustomer_args()
7930 
    args.read(iprot)
7931 
    iprot.readMessageEnd()
7932 
    result = getReturnableOrdersForCustomer_result()
7933 
    try:
7934 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7935 
    except TransactionServiceException, ex:
7936 
      result.ex = ex
7937 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7938 
    result.write(oprot)
7939 
    oprot.writeMessageEnd()
7940 
    oprot.trans.flush()
7941 
 
7942 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7943 
    args = getCancellableOrdersForCustomer_args()
7944 
    args.read(iprot)
7945 
    iprot.readMessageEnd()
7946 
    result = getCancellableOrdersForCustomer_result()
7947 
    try:
7948 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7949 
    except TransactionServiceException, ex:
7950 
      result.ex = ex
7951 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7952 
    result.write(oprot)
7953 
    oprot.writeMessageEnd()
7954 
    oprot.trans.flush()
7955 
 
483 rajveer 7956 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7957 
    args = changeOrderStatus_args()
94 ashish 7958 
    args.read(iprot)
7959 
    iprot.readMessageEnd()
483 rajveer 7960 
    result = changeOrderStatus_result()
94 ashish 7961 
    try:
483 rajveer 7962 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7963 
    except TransactionServiceException, ex:
7964 
      result.ex = ex
483 rajveer 7965 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7966 
    result.write(oprot)
7967 
    oprot.writeMessageEnd()
7968 
    oprot.trans.flush()
7969 
 
483 rajveer 7970 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7971 
    args = getOrdersForTransaction_args()
94 ashish 7972 
    args.read(iprot)
7973 
    iprot.readMessageEnd()
483 rajveer 7974 
    result = getOrdersForTransaction_result()
94 ashish 7975 
    try:
1528 ankur.sing 7976 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7977 
    except TransactionServiceException, ex:
7978 
      result.ex = ex
483 rajveer 7979 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7980 
    result.write(oprot)
7981 
    oprot.writeMessageEnd()
7982 
    oprot.trans.flush()
7983 
 
483 rajveer 7984 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7985 
    args = getOrdersForCustomer_args()
94 ashish 7986 
    args.read(iprot)
7987 
    iprot.readMessageEnd()
483 rajveer 7988 
    result = getOrdersForCustomer_result()
94 ashish 7989 
    try:
3014 chandransh 7990 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7991 
    except TransactionServiceException, ex:
7992 
      result.ex = ex
483 rajveer 7993 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7994 
    result.write(oprot)
7995 
    oprot.writeMessageEnd()
7996 
    oprot.trans.flush()
7997 
 
483 rajveer 7998 
  def process_createOrder(self, seqid, iprot, oprot):
7999 
    args = createOrder_args()
94 ashish 8000 
    args.read(iprot)
8001 
    iprot.readMessageEnd()
483 rajveer 8002 
    result = createOrder_result()
94 ashish 8003 
    try:
483 rajveer 8004 
      result.success = self._handler.createOrder(args.order)
94 ashish 8005 
    except TransactionServiceException, ex:
8006 
      result.ex = ex
483 rajveer 8007 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 8008 
    result.write(oprot)
8009 
    oprot.writeMessageEnd()
8010 
    oprot.trans.flush()
8011 
 
483 rajveer 8012 
  def process_getOrder(self, seqid, iprot, oprot):
8013 
    args = getOrder_args()
94 ashish 8014 
    args.read(iprot)
8015 
    iprot.readMessageEnd()
483 rajveer 8016 
    result = getOrder_result()
94 ashish 8017 
    try:
483 rajveer 8018 
      result.success = self._handler.getOrder(args.id)
94 ashish 8019 
    except TransactionServiceException, ex:
8020 
      result.ex = ex
483 rajveer 8021 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 8022 
    result.write(oprot)
8023 
    oprot.writeMessageEnd()
8024 
    oprot.trans.flush()
8025 
 
483 rajveer 8026 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
8027 
    args = getLineItemsForOrder_args()
94 ashish 8028 
    args.read(iprot)
8029 
    iprot.readMessageEnd()
483 rajveer 8030 
    result = getLineItemsForOrder_result()
94 ashish 8031 
    try:
483 rajveer 8032 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 8033 
    except TransactionServiceException, ex:
8034 
      result.ex = ex
483 rajveer 8035 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 8036 
    result.write(oprot)
8037 
    oprot.writeMessageEnd()
8038 
    oprot.trans.flush()
8039 
 
4999 phani.kuma 8040 
  def process_getOrderList(self, seqid, iprot, oprot):
8041 
    args = getOrderList_args()
8042 
    args.read(iprot)
8043 
    iprot.readMessageEnd()
8044 
    result = getOrderList_result()
8045 
    result.success = self._handler.getOrderList(args.order_ids)
8046 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
8047 
    result.write(oprot)
8048 
    oprot.writeMessageEnd()
8049 
    oprot.trans.flush()
8050 
 
5386 phani.kuma 8051 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
8052 
    args = getOrderListForVendor_args()
8053 
    args.read(iprot)
8054 
    iprot.readMessageEnd()
8055 
    result = getOrderListForVendor_result()
8056 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
8057 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
8058 
    result.write(oprot)
8059 
    oprot.writeMessageEnd()
8060 
    oprot.trans.flush()
8061 
 
1528 ankur.sing 8062 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
8063 
    args = getOrderForCustomer_args()
8064 
    args.read(iprot)
8065 
    iprot.readMessageEnd()
8066 
    result = getOrderForCustomer_result()
8067 
    try:
8068 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
8069 
    except TransactionServiceException, ex:
8070 
      result.ex = ex
8071 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
8072 
    result.write(oprot)
8073 
    oprot.writeMessageEnd()
8074 
    oprot.trans.flush()
8075 
 
3064 chandransh 8076 
  def process_getAlerts(self, seqid, iprot, oprot):
8077 
    args = getAlerts_args()
8078 
    args.read(iprot)
8079 
    iprot.readMessageEnd()
8080 
    result = getAlerts_result()
4444 rajveer 8081 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 8082 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
8083 
    result.write(oprot)
8084 
    oprot.writeMessageEnd()
8085 
    oprot.trans.flush()
8086 
 
4394 rajveer 8087 
  def process_addAlert(self, seqid, iprot, oprot):
8088 
    args = addAlert_args()
3064 chandransh 8089 
    args.read(iprot)
8090 
    iprot.readMessageEnd()
4394 rajveer 8091 
    result = addAlert_result()
4444 rajveer 8092 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 8093 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 8094 
    result.write(oprot)
8095 
    oprot.writeMessageEnd()
8096 
    oprot.trans.flush()
8097 
 
4444 rajveer 8098 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
8099 
    args = markAlertsAsSeen_args()
8100 
    args.read(iprot)
8101 
    iprot.readMessageEnd()
8102 
    result = markAlertsAsSeen_result()
8103 
    self._handler.markAlertsAsSeen(args.warehouseId)
8104 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
8105 
    result.write(oprot)
8106 
    oprot.writeMessageEnd()
8107 
    oprot.trans.flush()
8108 
 
3064 chandransh 8109 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
8110 
    args = getValidOrderCount_args()
8111 
    args.read(iprot)
8112 
    iprot.readMessageEnd()
8113 
    result = getValidOrderCount_result()
8114 
    result.success = self._handler.getValidOrderCount()
8115 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
8116 
    result.write(oprot)
8117 
    oprot.writeMessageEnd()
8118 
    oprot.trans.flush()
8119 
 
8120 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
8121 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
8122 
    args.read(iprot)
8123 
    iprot.readMessageEnd()
8124 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
8125 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
8126 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
8127 
    result.write(oprot)
8128 
    oprot.writeMessageEnd()
8129 
    oprot.trans.flush()
8130 
 
8131 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
8132 
    args = getValidOrdersAmountRange_args()
8133 
    args.read(iprot)
8134 
    iprot.readMessageEnd()
8135 
    result = getValidOrdersAmountRange_result()
8136 
    result.success = self._handler.getValidOrdersAmountRange()
8137 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
8138 
    result.write(oprot)
8139 
    oprot.writeMessageEnd()
8140 
    oprot.trans.flush()
8141 
 
8142 
  def process_getValidOrders(self, seqid, iprot, oprot):
8143 
    args = getValidOrders_args()
8144 
    args.read(iprot)
8145 
    iprot.readMessageEnd()
8146 
    result = getValidOrders_result()
5874 rajveer 8147 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 8148 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
8149 
    result.write(oprot)
8150 
    oprot.writeMessageEnd()
8151 
    oprot.trans.flush()
8152 
 
1220 chandransh 8153 
  def process_batchOrders(self, seqid, iprot, oprot):
8154 
    args = batchOrders_args()
8155 
    args.read(iprot)
8156 
    iprot.readMessageEnd()
8157 
    result = batchOrders_result()
8158 
    try:
8159 
      result.success = self._handler.batchOrders(args.warehouseId)
8160 
    except TransactionServiceException, ex:
8161 
      result.ex = ex
8162 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
8163 
    result.write(oprot)
8164 
    oprot.writeMessageEnd()
8165 
    oprot.trans.flush()
8166 
 
1208 chandransh 8167 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
8168 
    args = markOrderAsOutOfStock_args()
8169 
    args.read(iprot)
8170 
    iprot.readMessageEnd()
8171 
    result = markOrderAsOutOfStock_result()
8172 
    try:
8173 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
8174 
    except TransactionServiceException, ex:
8175 
      result.ex = ex
8176 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
8177 
    result.write(oprot)
8178 
    oprot.writeMessageEnd()
8179 
    oprot.trans.flush()
8180 
 
3064 chandransh 8181 
  def process_verifyOrder(self, seqid, iprot, oprot):
8182 
    args = verifyOrder_args()
759 chandransh 8183 
    args.read(iprot)
8184 
    iprot.readMessageEnd()
3064 chandransh 8185 
    result = verifyOrder_result()
759 chandransh 8186 
    try:
3064 chandransh 8187 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 8188 
    except TransactionServiceException, ex:
8189 
      result.ex = ex
3064 chandransh 8190 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 8191 
    result.write(oprot)
8192 
    oprot.writeMessageEnd()
8193 
    oprot.trans.flush()
8194 
 
3064 chandransh 8195 
  def process_acceptOrder(self, seqid, iprot, oprot):
8196 
    args = acceptOrder_args()
1113 chandransh 8197 
    args.read(iprot)
8198 
    iprot.readMessageEnd()
3064 chandransh 8199 
    result = acceptOrder_result()
1113 chandransh 8200 
    try:
3064 chandransh 8201 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 8202 
    except TransactionServiceException, ex:
8203 
      result.ex = ex
3064 chandransh 8204 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 8205 
    result.write(oprot)
8206 
    oprot.writeMessageEnd()
8207 
    oprot.trans.flush()
8208 
 
3064 chandransh 8209 
  def process_addBillingDetails(self, seqid, iprot, oprot):
8210 
    args = addBillingDetails_args()
1135 chandransh 8211 
    args.read(iprot)
8212 
    iprot.readMessageEnd()
3064 chandransh 8213 
    result = addBillingDetails_result()
1135 chandransh 8214 
    try:
7190 amar.kumar 8215 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.freebieWarehouseId, args.billed_by, args.jacketNumber, args.billingType, args.fulfilmentWarehouseId, args.authorize)
1135 chandransh 8216 
    except TransactionServiceException, ex:
8217 
      result.ex = ex
3064 chandransh 8218 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 8219 
    result.write(oprot)
8220 
    oprot.writeMessageEnd()
8221 
    oprot.trans.flush()
8222 
 
4579 rajveer 8223 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
8224 
    args = addInvoiceNumber_args()
8225 
    args.read(iprot)
8226 
    iprot.readMessageEnd()
8227 
    result = addInvoiceNumber_result()
8228 
    try:
6756 amar.kumar 8229 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 8230 
    except TransactionServiceException, ex:
8231 
      result.ex = ex
8232 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
8233 
    result.write(oprot)
8234 
    oprot.writeMessageEnd()
8235 
    oprot.trans.flush()
8236 
 
4410 rajveer 8237 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
8238 
    args = markOrdersAsShippedFromWarehouse_args()
8239 
    args.read(iprot)
8240 
    iprot.readMessageEnd()
8241 
    result = markOrdersAsShippedFromWarehouse_result()
8242 
    try:
4789 rajveer 8243 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 8244 
    except TransactionServiceException, ex:
8245 
      result.ex = ex
8246 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
8247 
    result.write(oprot)
8248 
    oprot.writeMessageEnd()
8249 
    oprot.trans.flush()
8250 
 
5676 rajveer 8251 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
8252 
    args = markOrdersAsReturnedFromStore_args()
8253 
    args.read(iprot)
8254 
    iprot.readMessageEnd()
8255 
    result = markOrdersAsReturnedFromStore_result()
8256 
    try:
5713 rajveer 8257 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 8258 
    except TransactionServiceException, ex:
8259 
      result.ex = ex
8260 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
8261 
    result.write(oprot)
8262 
    oprot.writeMessageEnd()
8263 
    oprot.trans.flush()
8264 
 
3064 chandransh 8265 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
8266 
    args = markOrdersAsPickedUp_args()
304 ashish 8267 
    args.read(iprot)
8268 
    iprot.readMessageEnd()
3064 chandransh 8269 
    result = markOrdersAsPickedUp_result()
8270 
    try:
4910 phani.kuma 8271 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 8272 
    except TransactionServiceException, ex:
8273 
      result.ex = ex
8274 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 8275 
    result.write(oprot)
8276 
    oprot.writeMessageEnd()
8277 
    oprot.trans.flush()
94 ashish 8278 
 
4910 phani.kuma 8279 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
8280 
    args = getOrdersNotPickedUp_args()
8281 
    args.read(iprot)
8282 
    iprot.readMessageEnd()
8283 
    result = getOrdersNotPickedUp_result()
8284 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
8285 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
8286 
    result.write(oprot)
8287 
    oprot.writeMessageEnd()
8288 
    oprot.trans.flush()
8289 
 
3064 chandransh 8290 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
8291 
    args = markOrdersAsDelivered_args()
304 ashish 8292 
    args.read(iprot)
8293 
    iprot.readMessageEnd()
3064 chandransh 8294 
    result = markOrdersAsDelivered_result()
8295 
    try:
8296 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
8297 
    except TransactionServiceException, ex:
8298 
      result.ex = ex
8299 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 8300 
    result.write(oprot)
8301 
    oprot.writeMessageEnd()
8302 
    oprot.trans.flush()
8303 
 
4910 phani.kuma 8304 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
8305 
    args = markAsRTOrders_args()
1596 ankur.sing 8306 
    args.read(iprot)
8307 
    iprot.readMessageEnd()
4910 phani.kuma 8308 
    result = markAsRTOrders_result()
3064 chandransh 8309 
    try:
4910 phani.kuma 8310 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 8311 
    except TransactionServiceException, ex:
8312 
      result.ex = ex
4910 phani.kuma 8313 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 8314 
    result.write(oprot)
8315 
    oprot.writeMessageEnd()
8316 
    oprot.trans.flush()
304 ashish 8317 
 
4910 phani.kuma 8318 
  def process_getRTOrders(self, seqid, iprot, oprot):
8319 
    args = getRTOrders_args()
8320 
    args.read(iprot)
8321 
    iprot.readMessageEnd()
8322 
    result = getRTOrders_result()
8323 
    result.success = self._handler.getRTOrders(args.providerId)
8324 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
8325 
    result.write(oprot)
8326 
    oprot.writeMessageEnd()
8327 
    oprot.trans.flush()
8328 
 
3064 chandransh 8329 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
8330 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 8331 
    args.read(iprot)
8332 
    iprot.readMessageEnd()
3064 chandransh 8333 
    result = updateNonDeliveryReason_result()
8334 
    try:
4910 phani.kuma 8335 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 8336 
    except TransactionServiceException, ex:
8337 
      result.ex = ex
8338 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 8339 
    result.write(oprot)
8340 
    oprot.writeMessageEnd()
8341 
    oprot.trans.flush()
1596 ankur.sing 8342 
 
4910 phani.kuma 8343 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
8344 
    args = getNonDeliveredOrdersbyCourier_args()
8345 
    args.read(iprot)
8346 
    iprot.readMessageEnd()
8347 
    result = getNonDeliveredOrdersbyCourier_result()
8348 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
8349 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
8350 
    result.write(oprot)
8351 
    oprot.writeMessageEnd()
8352 
    oprot.trans.flush()
8353 
 
8354 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
8355 
    args = markOrdersAsLocalConnected_args()
8356 
    args.read(iprot)
8357 
    iprot.readMessageEnd()
8358 
    result = markOrdersAsLocalConnected_result()
8359 
    try:
8360 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
8361 
    except TransactionServiceException, ex:
8362 
      result.ex = ex
8363 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
8364 
    result.write(oprot)
8365 
    oprot.writeMessageEnd()
8366 
    oprot.trans.flush()
8367 
 
8368 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
8369 
    args = getOrdersNotLocalConnected_args()
8370 
    args.read(iprot)
8371 
    iprot.readMessageEnd()
8372 
    result = getOrdersNotLocalConnected_result()
8373 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
8374 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
8375 
    result.write(oprot)
8376 
    oprot.writeMessageEnd()
8377 
    oprot.trans.flush()
8378 
 
8379 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
8380 
    args = markOrdersAsDestinationCityReached_args()
8381 
    args.read(iprot)
8382 
    iprot.readMessageEnd()
8383 
    result = markOrdersAsDestinationCityReached_result()
8384 
    try:
8385 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
8386 
    except TransactionServiceException, ex:
8387 
      result.ex = ex
8388 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
8389 
    result.write(oprot)
8390 
    oprot.writeMessageEnd()
8391 
    oprot.trans.flush()
8392 
 
8393 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
8394 
    args = markOrdersAsFirstDeliveryAttempted_args()
8395 
    args.read(iprot)
8396 
    iprot.readMessageEnd()
8397 
    result = markOrdersAsFirstDeliveryAttempted_result()
8398 
    try:
8399 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
8400 
    except TransactionServiceException, ex:
8401 
      result.ex = ex
8402 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
8403 
    result.write(oprot)
8404 
    oprot.writeMessageEnd()
8405 
    oprot.trans.flush()
8406 
 
3064 chandransh 8407 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
8408 
    args = getUndeliveredOrders_args()
1627 ankur.sing 8409 
    args.read(iprot)
8410 
    iprot.readMessageEnd()
3064 chandransh 8411 
    result = getUndeliveredOrders_result()
8412 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
8413 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 8414 
    result.write(oprot)
8415 
    oprot.writeMessageEnd()
8416 
    oprot.trans.flush()
8417 
 
4783 phani.kuma 8418 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
8419 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
8420 
    args.read(iprot)
8421 
    iprot.readMessageEnd()
8422 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
8423 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
8424 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
8425 
    result.write(oprot)
8426 
    oprot.writeMessageEnd()
8427 
    oprot.trans.flush()
8428 
 
2536 chandransh 8429 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
8430 
    args = toggleDOAFlag_args()
8431 
    args.read(iprot)
8432 
    iprot.readMessageEnd()
8433 
    result = toggleDOAFlag_result()
8434 
    try:
8435 
      result.success = self._handler.toggleDOAFlag(args.orderId)
8436 
    except TransactionServiceException, ex:
8437 
      result.ex = ex
8438 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
8439 
    result.write(oprot)
8440 
    oprot.writeMessageEnd()
8441 
    oprot.trans.flush()
1886 ankur.sing 8442 
 
4712 rajveer 8443 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
8444 
    args = markOrderAsDelivered_args()
8445 
    args.read(iprot)
8446 
    iprot.readMessageEnd()
8447 
    result = markOrderAsDelivered_result()
8448 
    try:
8449 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
8450 
    except TransactionServiceException, ex:
8451 
      result.ex = ex
8452 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
8453 
    result.write(oprot)
8454 
    oprot.writeMessageEnd()
8455 
    oprot.trans.flush()
8456 
 
5553 rajveer 8457 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
8458 
    args = markOrderAsReceivedAtStore_args()
8459 
    args.read(iprot)
8460 
    iprot.readMessageEnd()
8461 
    result = markOrderAsReceivedAtStore_result()
8462 
    try:
8463 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
8464 
    except TransactionServiceException, ex:
8465 
      result.ex = ex
8466 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
8467 
    result.write(oprot)
8468 
    oprot.writeMessageEnd()
8469 
    oprot.trans.flush()
8470 
 
4454 rajveer 8471 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
8472 
    args = markOrderDoaRequestReceived_args()
8473 
    args.read(iprot)
8474 
    iprot.readMessageEnd()
8475 
    result = markOrderDoaRequestReceived_result()
8476 
    try:
8477 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
8478 
    except TransactionServiceException, ex:
8479 
      result.ex = ex
8480 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
8481 
    result.write(oprot)
8482 
    oprot.writeMessageEnd()
8483 
    oprot.trans.flush()
8484 
 
8485 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
8486 
    args = markOrderDoaRequestAuthorized_args()
8487 
    args.read(iprot)
8488 
    iprot.readMessageEnd()
8489 
    result = markOrderDoaRequestAuthorized_result()
8490 
    try:
8491 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
8492 
    except TransactionServiceException, ex:
8493 
      result.ex = ex
8494 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
8495 
    result.write(oprot)
8496 
    oprot.writeMessageEnd()
8497 
    oprot.trans.flush()
8498 
 
4488 rajveer 8499 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
8500 
    args = markOrderReturnRequestReceived_args()
8501 
    args.read(iprot)
8502 
    iprot.readMessageEnd()
8503 
    result = markOrderReturnRequestReceived_result()
8504 
    try:
8505 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
8506 
    except TransactionServiceException, ex:
8507 
      result.ex = ex
8508 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8509 
    result.write(oprot)
8510 
    oprot.writeMessageEnd()
8511 
    oprot.trans.flush()
8512 
 
8513 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8514 
    args = markOrderReturnRequestAuthorized_args()
8515 
    args.read(iprot)
8516 
    iprot.readMessageEnd()
8517 
    result = markOrderReturnRequestAuthorized_result()
8518 
    try:
8519 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8520 
    except TransactionServiceException, ex:
8521 
      result.ex = ex
8522 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8523 
    result.write(oprot)
8524 
    oprot.writeMessageEnd()
8525 
    oprot.trans.flush()
8526 
 
2536 chandransh 8527 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8528 
    args = requestPickupNumber_args()
8529 
    args.read(iprot)
8530 
    iprot.readMessageEnd()
8531 
    result = requestPickupNumber_result()
8532 
    try:
4579 rajveer 8533 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8534 
    except TransactionServiceException, ex:
8535 
      result.ex = ex
8536 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8537 
    result.write(oprot)
8538 
    oprot.writeMessageEnd()
8539 
    oprot.trans.flush()
8540 
 
8541 
  def process_authorizePickup(self, seqid, iprot, oprot):
8542 
    args = authorizePickup_args()
8543 
    args.read(iprot)
8544 
    iprot.readMessageEnd()
8545 
    result = authorizePickup_result()
8546 
    try:
4602 rajveer 8547 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8548 
    except TransactionServiceException, ex:
8549 
      result.ex = ex
8550 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8551 
    result.write(oprot)
8552 
    oprot.writeMessageEnd()
8553 
    oprot.trans.flush()
8554 
 
2764 chandransh 8555 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8556 
    args = markDoasAsPickedUp_args()
8557 
    args.read(iprot)
8558 
    iprot.readMessageEnd()
8559 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8560 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8561 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8562 
    result.write(oprot)
8563 
    oprot.writeMessageEnd()
8564 
    oprot.trans.flush()
8565 
 
4910 phani.kuma 8566 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8567 
    args = getDoasNotPickedUp_args()
8568 
    args.read(iprot)
8569 
    iprot.readMessageEnd()
8570 
    result = getDoasNotPickedUp_result()
8571 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8572 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8573 
    result.write(oprot)
8574 
    oprot.writeMessageEnd()
8575 
    oprot.trans.flush()
8576 
 
4741 phani.kuma 8577 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8578 
    args = markReturnOrdersAsPickedUp_args()
8579 
    args.read(iprot)
8580 
    iprot.readMessageEnd()
8581 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8582 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8583 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8584 
    result.write(oprot)
8585 
    oprot.writeMessageEnd()
8586 
    oprot.trans.flush()
8587 
 
4910 phani.kuma 8588 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8589 
    args = getReturnOrdersNotPickedUp_args()
8590 
    args.read(iprot)
8591 
    iprot.readMessageEnd()
8592 
    result = getReturnOrdersNotPickedUp_result()
8593 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8594 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8595 
    result.write(oprot)
8596 
    oprot.writeMessageEnd()
8597 
    oprot.trans.flush()
8598 
 
2616 chandransh 8599 
  def process_receiveReturn(self, seqid, iprot, oprot):
8600 
    args = receiveReturn_args()
2591 chandransh 8601 
    args.read(iprot)
8602 
    iprot.readMessageEnd()
2616 chandransh 8603 
    result = receiveReturn_result()
2591 chandransh 8604 
    try:
4479 rajveer 8605 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8606 
    except TransactionServiceException, ex:
8607 
      result.ex = ex
2616 chandransh 8608 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8609 
    result.write(oprot)
8610 
    oprot.writeMessageEnd()
8611 
    oprot.trans.flush()
2536 chandransh 8612 
 
2591 chandransh 8613 
  def process_validateDoa(self, seqid, iprot, oprot):
8614 
    args = validateDoa_args()
8615 
    args.read(iprot)
8616 
    iprot.readMessageEnd()
8617 
    result = validateDoa_result()
8618 
    try:
8619 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8620 
    except TransactionServiceException, ex:
8621 
      result.ex = ex
8622 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8623 
    result.write(oprot)
8624 
    oprot.writeMessageEnd()
8625 
    oprot.trans.flush()
8626 
 
4495 rajveer 8627 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8628 
    args = validateReturnProduct_args()
8629 
    args.read(iprot)
8630 
    iprot.readMessageEnd()
8631 
    result = validateReturnProduct_result()
8632 
    try:
8633 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8634 
    except TransactionServiceException, ex:
8635 
      result.ex = ex
8636 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8637 
    result.write(oprot)
8638 
    oprot.writeMessageEnd()
8639 
    oprot.trans.flush()
8640 
 
2616 chandransh 8641 
  def process_reshipOrder(self, seqid, iprot, oprot):
8642 
    args = reshipOrder_args()
8643 
    args.read(iprot)
8644 
    iprot.readMessageEnd()
8645 
    result = reshipOrder_result()
8646 
    try:
8647 
      result.success = self._handler.reshipOrder(args.orderId)
8648 
    except TransactionServiceException, ex:
8649 
      result.ex = ex
8650 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8651 
    result.write(oprot)
8652 
    oprot.writeMessageEnd()
8653 
    oprot.trans.flush()
2591 chandransh 8654 
 
2616 chandransh 8655 
  def process_refundOrder(self, seqid, iprot, oprot):
8656 
    args = refundOrder_args()
8657 
    args.read(iprot)
8658 
    iprot.readMessageEnd()
8659 
    result = refundOrder_result()
8660 
    try:
3226 chandransh 8661 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8662 
    except TransactionServiceException, ex:
8663 
      result.ex = ex
8664 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8665 
    result.write(oprot)
8666 
    oprot.writeMessageEnd()
8667 
    oprot.trans.flush()
8668 
 
2690 chandransh 8669 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8670 
    args = getReturnOrders_args()
8671 
    args.read(iprot)
8672 
    iprot.readMessageEnd()
8673 
    result = getReturnOrders_result()
8674 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8675 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8676 
    result.write(oprot)
8677 
    oprot.writeMessageEnd()
8678 
    oprot.trans.flush()
2616 chandransh 8679 
 
5481 phani.kuma 8680 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8681 
    args = getAllReturnOrders_args()
8682 
    args.read(iprot)
8683 
    iprot.readMessageEnd()
8684 
    result = getAllReturnOrders_result()
8685 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8686 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8687 
    result.write(oprot)
8688 
    oprot.writeMessageEnd()
8689 
    oprot.trans.flush()
8690 
 
2700 chandransh 8691 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8692 
    args = getReturnOrder_args()
8693 
    args.read(iprot)
8694 
    iprot.readMessageEnd()
8695 
    result = getReturnOrder_result()
8696 
    try:
8697 
      result.success = self._handler.getReturnOrder(args.id)
8698 
    except TransactionServiceException, ex:
8699 
      result.ex = ex
8700 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8701 
    result.write(oprot)
8702 
    oprot.writeMessageEnd()
8703 
    oprot.trans.flush()
8704 
 
2690 chandransh 8705 
  def process_processReturn(self, seqid, iprot, oprot):
8706 
    args = processReturn_args()
8707 
    args.read(iprot)
8708 
    iprot.readMessageEnd()
8709 
    result = processReturn_result()
8710 
    try:
8711 
      self._handler.processReturn(args.returnOrderId)
8712 
    except TransactionServiceException, ex:
8713 
      result.ex = ex
8714 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8715 
    result.write(oprot)
8716 
    oprot.writeMessageEnd()
8717 
    oprot.trans.flush()
8718 
 
3451 chandransh 8719 
  def process_updateWeight(self, seqid, iprot, oprot):
8720 
    args = updateWeight_args()
8721 
    args.read(iprot)
8722 
    iprot.readMessageEnd()
8723 
    result = updateWeight_result()
8724 
    try:
8725 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8726 
    except TransactionServiceException, ex:
8727 
      result.ex = ex
8728 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8729 
    result.write(oprot)
8730 
    oprot.writeMessageEnd()
8731 
    oprot.trans.flush()
2819 chandransh 8732 
 
3469 chandransh 8733 
  def process_changeItem(self, seqid, iprot, oprot):
8734 
    args = changeItem_args()
8735 
    args.read(iprot)
8736 
    iprot.readMessageEnd()
8737 
    result = changeItem_result()
8738 
    try:
8739 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8740 
    except TransactionServiceException, ex:
8741 
      result.ex = ex
8742 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8743 
    result.write(oprot)
8744 
    oprot.writeMessageEnd()
8745 
    oprot.trans.flush()
3451 chandransh 8746 
 
3469 chandransh 8747 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8748 
    args = shiftToWarehouse_args()
8749 
    args.read(iprot)
8750 
    iprot.readMessageEnd()
8751 
    result = shiftToWarehouse_result()
8752 
    try:
8753 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8754 
    except TransactionServiceException, ex:
8755 
      result.ex = ex
8756 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8757 
    result.write(oprot)
8758 
    oprot.writeMessageEnd()
8759 
    oprot.trans.flush()
8760 
 
3553 chandransh 8761 
  def process_addDelayReason(self, seqid, iprot, oprot):
8762 
    args = addDelayReason_args()
8763 
    args.read(iprot)
8764 
    iprot.readMessageEnd()
8765 
    result = addDelayReason_result()
8766 
    try:
4647 rajveer 8767 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8768 
    except TransactionServiceException, ex:
8769 
      result.ex = ex
8770 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8771 
    result.write(oprot)
8772 
    oprot.writeMessageEnd()
8773 
    oprot.trans.flush()
3469 chandransh 8774 
 
3956 chandransh 8775 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8776 
    args = reconcileCodCollection_args()
8777 
    args.read(iprot)
8778 
    iprot.readMessageEnd()
8779 
    result = reconcileCodCollection_result()
8780 
    try:
8781 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8782 
    except TransactionServiceException, ex:
8783 
      result.ex = ex
8784 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8785 
    result.write(oprot)
8786 
    oprot.writeMessageEnd()
8787 
    oprot.trans.flush()
3553 chandransh 8788 
 
4008 mandeep.dh 8789 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8790 
    args = getTransactionsRequiringExtraProcessing_args()
8791 
    args.read(iprot)
8792 
    iprot.readMessageEnd()
8793 
    result = getTransactionsRequiringExtraProcessing_result()
8794 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8795 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8796 
    result.write(oprot)
8797 
    oprot.writeMessageEnd()
8798 
    oprot.trans.flush()
3956 chandransh 8799 
 
4008 mandeep.dh 8800 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8801 
    args = markTransactionAsProcessed_args()
8802 
    args.read(iprot)
8803 
    iprot.readMessageEnd()
8804 
    result = markTransactionAsProcessed_result()
8805 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8806 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8807 
    result.write(oprot)
8808 
    oprot.writeMessageEnd()
8809 
    oprot.trans.flush()
8810 
 
4018 chandransh 8811 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8812 
    args = getItemWiseRiskyOrdersCount_args()
8813 
    args.read(iprot)
8814 
    iprot.readMessageEnd()
8815 
    result = getItemWiseRiskyOrdersCount_result()
8816 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8817 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8818 
    result.write(oprot)
8819 
    oprot.writeMessageEnd()
8820 
    oprot.trans.flush()
4008 mandeep.dh 8821 
 
4295 varun.gupt 8822 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8823 
    args = getOrdersForItemIds_args()
8824 
    args.read(iprot)
8825 
    iprot.readMessageEnd()
8826 
    result = getOrdersForItemIds_result()
8827 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8828 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8829 
    result.write(oprot)
8830 
    oprot.writeMessageEnd()
8831 
    oprot.trans.flush()
8832 
 
4247 rajveer 8833 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8834 
    args = markOrderCancellationRequestReceived_args()
8835 
    args.read(iprot)
8836 
    iprot.readMessageEnd()
8837 
    result = markOrderCancellationRequestReceived_result()
8838 
    try:
8839 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8840 
    except TransactionServiceException, ex:
8841 
      result.ex = ex
8842 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8843 
    result.write(oprot)
8844 
    oprot.writeMessageEnd()
8845 
    oprot.trans.flush()
4018 chandransh 8846 
 
4247 rajveer 8847 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8848 
    args = markOrderCancellationRequestConfirmed_args()
8849 
    args.read(iprot)
8850 
    iprot.readMessageEnd()
8851 
    result = markOrderCancellationRequestConfirmed_result()
8852 
    try:
8853 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8854 
    except TransactionServiceException, ex:
8855 
      result.ex = ex
8856 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8857 
    result.write(oprot)
8858 
    oprot.writeMessageEnd()
8859 
    oprot.trans.flush()
8860 
 
8861 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8862 
    args = markOrderCancellationRequestDenied_args()
8863 
    args.read(iprot)
8864 
    iprot.readMessageEnd()
8865 
    result = markOrderCancellationRequestDenied_result()
8866 
    try:
8867 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8868 
    except TransactionServiceException, ex:
8869 
      result.ex = ex
8870 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8871 
    result.write(oprot)
8872 
    oprot.writeMessageEnd()
8873 
    oprot.trans.flush()
8874 
 
4258 rajveer 8875 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8876 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8877 
    args.read(iprot)
8878 
    iprot.readMessageEnd()
4258 rajveer 8879 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8880 
    try:
4258 rajveer 8881 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8882 
    except TransactionServiceException, ex:
8883 
      result.ex = ex
4258 rajveer 8884 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8885 
    result.write(oprot)
8886 
    oprot.writeMessageEnd()
8887 
    oprot.trans.flush()
8888 
 
4259 anupam.sin 8889 
  def process_refundTransaction(self, seqid, iprot, oprot):
8890 
    args = refundTransaction_args()
8891 
    args.read(iprot)
8892 
    iprot.readMessageEnd()
8893 
    result = refundTransaction_result()
8894 
    try:
8895 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8896 
    except TransactionServiceException, ex:
8897 
      result.ex = ex
8898 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8899 
    result.write(oprot)
8900 
    oprot.writeMessageEnd()
8901 
    oprot.trans.flush()
4247 rajveer 8902 
 
4324 mandeep.dh 8903 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8904 
    args = updateShipmentAddress_args()
8905 
    args.read(iprot)
8906 
    iprot.readMessageEnd()
8907 
    result = updateShipmentAddress_result()
8908 
    try:
8909 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8910 
    except TransactionServiceException, ex:
8911 
      result.ex = ex
8912 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8913 
    result.write(oprot)
8914 
    oprot.writeMessageEnd()
8915 
    oprot.trans.flush()
8916 
 
4285 rajveer 8917 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8918 
    args = acceptOrdersForItemId_args()
8919 
    args.read(iprot)
8920 
    iprot.readMessageEnd()
8921 
    result = acceptOrdersForItemId_result()
8922 
    try:
8923 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8924 
    except TransactionServiceException, ex:
8925 
      result.ex = ex
8926 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8927 
    result.write(oprot)
8928 
    oprot.writeMessageEnd()
8929 
    oprot.trans.flush()
4259 anupam.sin 8930 
 
4303 rajveer 8931 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8932 
    args = markOrdersAsPORaised_args()
8933 
    args.read(iprot)
8934 
    iprot.readMessageEnd()
8935 
    result = markOrdersAsPORaised_result()
8936 
    try:
4369 rajveer 8937 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8938 
    except TransactionServiceException, ex:
8939 
      result.ex = ex
8940 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8941 
    result.write(oprot)
8942 
    oprot.writeMessageEnd()
8943 
    oprot.trans.flush()
4285 rajveer 8944 
 
4303 rajveer 8945 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8946 
    args = markOrdersAsReversalInitiated_args()
8947 
    args.read(iprot)
8948 
    iprot.readMessageEnd()
8949 
    result = markOrdersAsReversalInitiated_result()
8950 
    try:
4369 rajveer 8951 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8952 
    except TransactionServiceException, ex:
8953 
      result.ex = ex
8954 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8955 
    result.write(oprot)
8956 
    oprot.writeMessageEnd()
8957 
    oprot.trans.flush()
8958 
 
8959 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8960 
    args = markOrdersAsNotAvailabke_args()
8961 
    args.read(iprot)
8962 
    iprot.readMessageEnd()
8963 
    result = markOrdersAsNotAvailabke_result()
8964 
    try:
4369 rajveer 8965 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8966 
    except TransactionServiceException, ex:
8967 
      result.ex = ex
8968 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8969 
    result.write(oprot)
8970 
    oprot.writeMessageEnd()
8971 
    oprot.trans.flush()
8972 
 
4369 rajveer 8973 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8974 
    args = markOrdersAsTimeout_args()
8975 
    args.read(iprot)
8976 
    iprot.readMessageEnd()
8977 
    result = markOrdersAsTimeout_result()
8978 
    try:
8979 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8980 
    except TransactionServiceException, ex:
8981 
      result.ex = ex
8982 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8983 
    result.write(oprot)
8984 
    oprot.writeMessageEnd()
8985 
    oprot.trans.flush()
4303 rajveer 8986 
 
4662 rajveer 8987 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8988 
    args = markOrderAsLostInTransit_args()
8989 
    args.read(iprot)
8990 
    iprot.readMessageEnd()
8991 
    result = markOrderAsLostInTransit_result()
8992 
    try:
8993 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8994 
    except TransactionServiceException, ex:
8995 
      result.ex = ex
8996 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8997 
    result.write(oprot)
8998 
    oprot.writeMessageEnd()
8999 
    oprot.trans.flush()
9000 
 
4386 anupam.sin 9001 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
9002 
    args = getOrderForAwb_args()
9003 
    args.read(iprot)
9004 
    iprot.readMessageEnd()
9005 
    result = getOrderForAwb_result()
9006 
    try:
9007 
      result.success = self._handler.getOrderForAwb(args.awb)
9008 
    except TransactionServiceException, ex:
9009 
      result.ex = ex
9010 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
9011 
    result.write(oprot)
9012 
    oprot.writeMessageEnd()
9013 
    oprot.trans.flush()
4369 rajveer 9014 
 
4506 phani.kuma 9015 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
9016 
    args = getOrdersForProviderForStatus_args()
9017 
    args.read(iprot)
9018 
    iprot.readMessageEnd()
9019 
    result = getOrdersForProviderForStatus_result()
9020 
    try:
4910 phani.kuma 9021 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 9022 
    except TransactionServiceException, ex:
9023 
      result.ex = ex
9024 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
9025 
    result.write(oprot)
9026 
    oprot.writeMessageEnd()
9027 
    oprot.trans.flush()
4386 anupam.sin 9028 
 
4600 varun.gupt 9029 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
9030 
    args = getBilledOrdersForVendor_args()
9031 
    args.read(iprot)
9032 
    iprot.readMessageEnd()
9033 
    result = getBilledOrdersForVendor_result()
9034 
    try:
9035 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
9036 
    except TransactionServiceException, ex:
9037 
      result.ex = ex
9038 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
9039 
    result.write(oprot)
9040 
    oprot.writeMessageEnd()
9041 
    oprot.trans.flush()
4506 phani.kuma 9042 
 
4607 rajveer 9043 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
9044 
    args = getSlippedSippingDateOrders_args()
9045 
    args.read(iprot)
9046 
    iprot.readMessageEnd()
9047 
    result = getSlippedSippingDateOrders_result()
9048 
    try:
9049 
      result.success = self._handler.getSlippedSippingDateOrders()
9050 
    except TransactionServiceException, ex:
9051 
      result.ex = ex
9052 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
9053 
    result.write(oprot)
9054 
    oprot.writeMessageEnd()
9055 
    oprot.trans.flush()
9056 
 
4709 rajveer 9057 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
9058 
    args = getCancelledOrders_args()
9059 
    args.read(iprot)
9060 
    iprot.readMessageEnd()
9061 
    result = getCancelledOrders_result()
9062 
    try:
9063 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
9064 
    except TransactionServiceException, ex:
9065 
      result.ex = ex
9066 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
9067 
    result.write(oprot)
9068 
    oprot.writeMessageEnd()
9069 
    oprot.trans.flush()
9070 
 
4600 varun.gupt 9071 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
9072 
    args = saveBluedartSettlements_args()
9073 
    args.read(iprot)
9074 
    iprot.readMessageEnd()
9075 
    result = saveBluedartSettlements_result()
9076 
    try:
9077 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
9078 
    except TransactionServiceException, ex:
9079 
      result.ex = ex
9080 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
9081 
    result.write(oprot)
9082 
    oprot.writeMessageEnd()
9083 
    oprot.trans.flush()
9084 
 
9085 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
9086 
    args = savePaymentSettlements_args()
9087 
    args.read(iprot)
9088 
    iprot.readMessageEnd()
9089 
    result = savePaymentSettlements_result()
9090 
    try:
4905 varun.gupt 9091 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 9092 
    except TransactionServiceException, ex:
9093 
      result.ex = ex
9094 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
9095 
    result.write(oprot)
9096 
    oprot.writeMessageEnd()
9097 
    oprot.trans.flush()
9098 
 
9099 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
9100 
    args = saveEBSSettlementSummary_args()
9101 
    args.read(iprot)
9102 
    iprot.readMessageEnd()
9103 
    result = saveEBSSettlementSummary_result()
9104 
    try:
9105 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
9106 
    except TransactionServiceException, ex:
9107 
      result.ex = ex
9108 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
9109 
    result.write(oprot)
9110 
    oprot.writeMessageEnd()
9111 
    oprot.trans.flush()
9112 
 
5386 phani.kuma 9113 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
9114 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 9115 
    args.read(iprot)
9116 
    iprot.readMessageEnd()
5386 phani.kuma 9117 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 9118 
    try:
5386 phani.kuma 9119 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 9120 
    except TransactionServiceException, ex:
9121 
      result.ex = ex
5386 phani.kuma 9122 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 9123 
    result.write(oprot)
9124 
    oprot.writeMessageEnd()
9125 
    oprot.trans.flush()
9126 
 
5386 phani.kuma 9127 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
9128 
    args = getSettlementForCod_args()
9129 
    args.read(iprot)
9130 
    iprot.readMessageEnd()
9131 
    result = getSettlementForCod_result()
9132 
    try:
9133 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
9134 
    except TransactionServiceException, ex:
9135 
      result.ex = ex
9136 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
9137 
    result.write(oprot)
9138 
    oprot.writeMessageEnd()
9139 
    oprot.trans.flush()
9140 
 
4600 varun.gupt 9141 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
9142 
    args = getEBSSettlementSummaries_args()
9143 
    args.read(iprot)
9144 
    iprot.readMessageEnd()
9145 
    result = getEBSSettlementSummaries_result()
9146 
    try:
9147 
      result.success = self._handler.getEBSSettlementSummaries()
9148 
    except TransactionServiceException, ex:
9149 
      result.ex = ex
9150 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
9151 
    result.write(oprot)
9152 
    oprot.writeMessageEnd()
9153 
    oprot.trans.flush()
9154 
 
9155 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
9156 
    args = markEBSSettlementUploaded_args()
9157 
    args.read(iprot)
9158 
    iprot.readMessageEnd()
9159 
    result = markEBSSettlementUploaded_result()
9160 
    try:
9161 
      self._handler.markEBSSettlementUploaded(args.settlementId)
9162 
    except TransactionServiceException, ex:
9163 
      result.ex = ex
9164 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
9165 
    result.write(oprot)
9166 
    oprot.writeMessageEnd()
9167 
    oprot.trans.flush()
9168 
 
9169 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
9170 
    args = getEBSSettlementDate_args()
9171 
    args.read(iprot)
9172 
    iprot.readMessageEnd()
9173 
    result = getEBSSettlementDate_result()
9174 
    try:
9175 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
9176 
    except TransactionServiceException, ex:
9177 
      result.ex = ex
9178 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
9179 
    result.write(oprot)
9180 
    oprot.writeMessageEnd()
9181 
    oprot.trans.flush()
9182 
 
4715 varun.gupt 9183 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
9184 
    args = getSettlementsByDate_args()
9185 
    args.read(iprot)
9186 
    iprot.readMessageEnd()
9187 
    result = getSettlementsByDate_result()
9188 
    try:
9189 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
9190 
    except TransactionServiceException, ex:
9191 
      result.ex = ex
9192 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
9193 
    result.write(oprot)
9194 
    oprot.writeMessageEnd()
9195 
    oprot.trans.flush()
4600 varun.gupt 9196 
 
4715 varun.gupt 9197 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
9198 
    args = getReshippedOrderIds_args()
9199 
    args.read(iprot)
9200 
    iprot.readMessageEnd()
9201 
    result = getReshippedOrderIds_result()
9202 
    try:
9203 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
9204 
    except TransactionServiceException, ex:
9205 
      result.ex = ex
9206 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
9207 
    result.write(oprot)
9208 
    oprot.writeMessageEnd()
9209 
    oprot.trans.flush()
9210 
 
5481 phani.kuma 9211 
  def process_getBilledOrders(self, seqid, iprot, oprot):
9212 
    args = getBilledOrders_args()
4875 varun.gupt 9213 
    args.read(iprot)
9214 
    iprot.readMessageEnd()
5481 phani.kuma 9215 
    result = getBilledOrders_result()
4875 varun.gupt 9216 
    try:
5481 phani.kuma 9217 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 9218 
    except TransactionServiceException, ex:
9219 
      result.ex = ex
5481 phani.kuma 9220 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 9221 
    result.write(oprot)
9222 
    oprot.writeMessageEnd()
9223 
    oprot.trans.flush()
4757 mandeep.dh 9224 
 
5031 varun.gupt 9225 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
9226 
    args = getStatusDistributionOfOrders_args()
9227 
    args.read(iprot)
9228 
    iprot.readMessageEnd()
9229 
    result = getStatusDistributionOfOrders_result()
9230 
    try:
9231 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
9232 
    except TransactionServiceException, ex:
9233 
      result.ex = ex
9234 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
9235 
    result.write(oprot)
9236 
    oprot.writeMessageEnd()
9237 
    oprot.trans.flush()
4875 varun.gupt 9238 
 
5067 varun.gupt 9239 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
9240 
    args = getOrderIdsForStatus_args()
9241 
    args.read(iprot)
9242 
    iprot.readMessageEnd()
9243 
    result = getOrderIdsForStatus_result()
9244 
    try:
9245 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
9246 
    except TransactionServiceException, ex:
9247 
      result.ex = ex
9248 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
9249 
    result.write(oprot)
9250 
    oprot.writeMessageEnd()
9251 
    oprot.trans.flush()
5031 varun.gupt 9252 
 
5348 anupam.sin 9253 
  def process_updateCODAgent(self, seqid, iprot, oprot):
9254 
    args = updateCODAgent_args()
9255 
    args.read(iprot)
9256 
    iprot.readMessageEnd()
9257 
    result = updateCODAgent_result()
9258 
    try:
9259 
      self._handler.updateCODAgent(args.agent, args.orderId)
9260 
    except TransactionServiceException, ex:
9261 
      result.ex = ex
9262 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
9263 
    result.write(oprot)
9264 
    oprot.writeMessageEnd()
9265 
    oprot.trans.flush()
9266 
 
5099 varun.gupt 9267 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
9268 
    args = updateOrderAsPaidToVendor_args()
9269 
    args.read(iprot)
9270 
    iprot.readMessageEnd()
9271 
    result = updateOrderAsPaidToVendor_result()
9272 
    try:
9273 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
9274 
    except TransactionServiceException, ex:
9275 
      result.ex = ex
9276 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
9277 
    result.write(oprot)
9278 
    oprot.writeMessageEnd()
9279 
    oprot.trans.flush()
5067 varun.gupt 9280 
 
5386 phani.kuma 9281 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
9282 
    args = updateOrderOnlyAsPaidToVendor_args()
9283 
    args.read(iprot)
9284 
    iprot.readMessageEnd()
9285 
    result = updateOrderOnlyAsPaidToVendor_result()
9286 
    try:
9287 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
9288 
    except TransactionServiceException, ex:
9289 
      result.ex = ex
9290 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
9291 
    result.write(oprot)
9292 
    oprot.writeMessageEnd()
9293 
    oprot.trans.flush()
9294 
 
5208 varun.gupt 9295 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
9296 
    args = getRefundedOrdersMarkedPaid_args()
9297 
    args.read(iprot)
9298 
    iprot.readMessageEnd()
9299 
    result = getRefundedOrdersMarkedPaid_result()
9300 
    try:
9301 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
9302 
    except TransactionServiceException, ex:
9303 
      result.ex = ex
9304 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
9305 
    result.write(oprot)
9306 
    oprot.writeMessageEnd()
9307 
    oprot.trans.flush()
5099 varun.gupt 9308 
 
5447 anupam.sin 9309 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
9310 
    args = getAllVerificationAgents_args()
9311 
    args.read(iprot)
9312 
    iprot.readMessageEnd()
9313 
    result = getAllVerificationAgents_result()
9314 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
9315 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
9316 
    result.write(oprot)
9317 
    oprot.writeMessageEnd()
9318 
    oprot.trans.flush()
5208 varun.gupt 9319 
 
5527 anupam.sin 9320 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
9321 
    args = getAllAttributesForOrderId_args()
9322 
    args.read(iprot)
9323 
    iprot.readMessageEnd()
9324 
    result = getAllAttributesForOrderId_result()
9325 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
9326 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
9327 
    result.write(oprot)
9328 
    oprot.writeMessageEnd()
9329 
    oprot.trans.flush()
5447 anupam.sin 9330 
 
5676 rajveer 9331 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
9332 
    args = setOrderAttributes_args()
9333 
    args.read(iprot)
9334 
    iprot.readMessageEnd()
9335 
    result = setOrderAttributes_result()
9336 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
9337 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
9338 
    result.write(oprot)
9339 
    oprot.writeMessageEnd()
9340 
    oprot.trans.flush()
9341 
 
5527 anupam.sin 9342 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
9343 
    args = setOrderAttributeForTransaction_args()
9344 
    args.read(iprot)
9345 
    iprot.readMessageEnd()
9346 
    result = setOrderAttributeForTransaction_result()
9347 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
9348 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
9349 
    result.write(oprot)
9350 
    oprot.writeMessageEnd()
9351 
    oprot.trans.flush()
9352 
 
5553 rajveer 9353 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
9354 
    args = getReceivePendingOrders_args()
9355 
    args.read(iprot)
9356 
    iprot.readMessageEnd()
9357 
    result = getReceivePendingOrders_result()
9358 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
9359 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
9360 
    result.write(oprot)
9361 
    oprot.writeMessageEnd()
9362 
    oprot.trans.flush()
5527 anupam.sin 9363 
 
5553 rajveer 9364 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
9365 
    args = getReceivedAtStoreOrders_args()
9366 
    args.read(iprot)
9367 
    iprot.readMessageEnd()
9368 
    result = getReceivedAtStoreOrders_result()
9369 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
9370 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
9371 
    result.write(oprot)
9372 
    oprot.writeMessageEnd()
9373 
    oprot.trans.flush()
9374 
 
5713 rajveer 9375 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
9376 
    args = getOrdersCollectionAtStore_args()
9377 
    args.read(iprot)
9378 
    iprot.readMessageEnd()
9379 
    result = getOrdersCollectionAtStore_result()
9380 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
9381 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
9382 
    result.write(oprot)
9383 
    oprot.writeMessageEnd()
9384 
    oprot.trans.flush()
9385 
 
5833 rajveer 9386 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
9387 
    args = getOrderAttributeValue_args()
9388 
    args.read(iprot)
9389 
    iprot.readMessageEnd()
9390 
    result = getOrderAttributeValue_result()
9391 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
9392 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
9393 
    result.write(oprot)
9394 
    oprot.writeMessageEnd()
9395 
    oprot.trans.flush()
9396 
 
6019 rajveer 9397 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
9398 
    args = changeJacketNumber_args()
9399 
    args.read(iprot)
9400 
    iprot.readMessageEnd()
9401 
    result = changeJacketNumber_result()
9402 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
9403 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
9404 
    result.write(oprot)
9405 
    oprot.writeMessageEnd()
9406 
    oprot.trans.flush()
9407 
 
9408 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
9409 
    args = markOrderAsRtoInTransit_args()
9410 
    args.read(iprot)
9411 
    iprot.readMessageEnd()
9412 
    result = markOrderAsRtoInTransit_result()
9413 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
9414 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
9415 
    result.write(oprot)
9416 
    oprot.writeMessageEnd()
9417 
    oprot.trans.flush()
9418 
 
5593 mandeep.dh 9419 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
9420 
    args = acceptOrderForItem_args()
9421 
    args.read(iprot)
9422 
    iprot.readMessageEnd()
9423 
    result = acceptOrderForItem_result()
9424 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
9425 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
9426 
    result.write(oprot)
9427 
    oprot.writeMessageEnd()
9428 
    oprot.trans.flush()
5553 rajveer 9429 
 
6000 mandeep.dh 9430 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
9431 
    args = createRechargeOrder_args()
9432 
    args.read(iprot)
9433 
    iprot.readMessageEnd()
9434 
    result = createRechargeOrder_result()
9435 
    try:
9436 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
9437 
    except TransactionServiceException, ex:
9438 
      result.ex = ex
9439 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
9440 
    result.write(oprot)
9441 
    oprot.writeMessageEnd()
9442 
    oprot.trans.flush()
5593 mandeep.dh 9443 
 
6031 rajveer 9444 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
9445 
    args = getRechargeOrder_args()
9446 
    args.read(iprot)
9447 
    iprot.readMessageEnd()
9448 
    result = getRechargeOrder_result()
9449 
    try:
9450 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
9451 
    except TransactionServiceException, ex:
9452 
      result.ex = ex
9453 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
9454 
    result.write(oprot)
9455 
    oprot.writeMessageEnd()
9456 
    oprot.trans.flush()
9457 
 
9458 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
9459 
    args = getRechargeOrders_args()
9460 
    args.read(iprot)
9461 
    iprot.readMessageEnd()
9462 
    result = getRechargeOrders_result()
9463 
    result.success = self._handler.getRechargeOrders(args.userId)
9464 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
9465 
    result.write(oprot)
9466 
    oprot.writeMessageEnd()
9467 
    oprot.trans.flush()
9468 
 
6000 mandeep.dh 9469 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
9470 
    args = updateRechargeOrderStatus_args()
9471 
    args.read(iprot)
9472 
    iprot.readMessageEnd()
9473 
    result = updateRechargeOrderStatus_result()
9474 
    try:
6031 rajveer 9475 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 9476 
    except TransactionServiceException, ex:
9477 
      result.ex = ex
9478 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
9479 
    result.write(oprot)
9480 
    oprot.writeMessageEnd()
9481 
    oprot.trans.flush()
9482 
 
9483 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
9484 
    args = activateRechargeTxn_args()
9485 
    args.read(iprot)
9486 
    iprot.readMessageEnd()
9487 
    result = activateRechargeTxn_result()
9488 
    try:
6031 rajveer 9489 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 9490 
    except TransactionServiceException, ex:
9491 
      result.ex = ex
9492 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
9493 
    result.write(oprot)
9494 
    oprot.writeMessageEnd()
9495 
    oprot.trans.flush()
9496 
 
6031 rajveer 9497 
  def process_getUserWallet(self, seqid, iprot, oprot):
9498 
    args = getUserWallet_args()
6000 mandeep.dh 9499 
    args.read(iprot)
9500 
    iprot.readMessageEnd()
6031 rajveer 9501 
    result = getUserWallet_result()
9502 
    result.success = self._handler.getUserWallet(args.userId)
9503 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 9504 
    result.write(oprot)
9505 
    oprot.writeMessageEnd()
9506 
    oprot.trans.flush()
9507 
 
6031 rajveer 9508 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9509 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9510 
    args.read(iprot)
9511 
    iprot.readMessageEnd()
6031 rajveer 9512 
    result = getUserWalletHistory_result()
9513 
    result.success = self._handler.getUserWalletHistory(args.userId)
9514 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9515 
    result.write(oprot)
9516 
    oprot.writeMessageEnd()
9517 
    oprot.trans.flush()
9518 
 
6050 anupam.sin 9519 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9520 
    args = getRechargeOrdersForTransaction_args()
9521 
    args.read(iprot)
9522 
    iprot.readMessageEnd()
9523 
    result = getRechargeOrdersForTransaction_result()
9524 
    try:
9525 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9526 
    except TransactionServiceException, ex:
9527 
      result.ex = ex
9528 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9529 
    result.write(oprot)
9530 
    oprot.writeMessageEnd()
9531 
    oprot.trans.flush()
9532 
 
6048 rajveer 9533 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9534 
    args = getServiceProviders_args()
9535 
    args.read(iprot)
9536 
    iprot.readMessageEnd()
9537 
    result = getServiceProviders_result()
6206 rajveer 9538 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9539 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9540 
    result.write(oprot)
9541 
    oprot.writeMessageEnd()
9542 
    oprot.trans.flush()
6000 mandeep.dh 9543 
 
6048 rajveer 9544 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9545 
    args = getServiceProviderForDevice_args()
9546 
    args.read(iprot)
9547 
    iprot.readMessageEnd()
9548 
    result = getServiceProviderForDevice_result()
6049 rajveer 9549 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9550 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9551 
    result.write(oprot)
9552 
    oprot.writeMessageEnd()
9553 
    oprot.trans.flush()
9554 
 
6269 rajveer 9555 
  def process_validateRecharge(self, seqid, iprot, oprot):
9556 
    args = validateRecharge_args()
9557 
    args.read(iprot)
9558 
    iprot.readMessageEnd()
9559 
    result = validateRecharge_result()
6591 anupam.sin 9560 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9561 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9562 
    result.write(oprot)
9563 
    oprot.writeMessageEnd()
9564 
    oprot.trans.flush()
9565 
 
6094 rajveer 9566 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9567 
    args = getRechargeOrdersForDevice_args()
9568 
    args.read(iprot)
9569 
    iprot.readMessageEnd()
9570 
    result = getRechargeOrdersForDevice_result()
9571 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9572 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9573 
    result.write(oprot)
9574 
    oprot.writeMessageEnd()
9575 
    oprot.trans.flush()
6048 rajveer 9576 
 
6094 rajveer 9577 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9578 
    args = addAmountToWallet_args()
9579 
    args.read(iprot)
9580 
    iprot.readMessageEnd()
9581 
    result = addAmountToWallet_result()
9582 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9583 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9584 
    result.write(oprot)
9585 
    oprot.writeMessageEnd()
9586 
    oprot.trans.flush()
9587 
 
6188 rajveer 9588 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9589 
    args = getRechargeStatistics_args()
9590 
    args.read(iprot)
9591 
    iprot.readMessageEnd()
9592 
    result = getRechargeStatistics_result()
9593 
    result.success = self._handler.getRechargeStatistics()
9594 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9595 
    result.write(oprot)
9596 
    oprot.writeMessageEnd()
9597 
    oprot.trans.flush()
9598 
 
6154 rajveer 9599 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9600 
    args = getRechargeOrdersForStatus_args()
9601 
    args.read(iprot)
9602 
    iprot.readMessageEnd()
9603 
    result = getRechargeOrdersForStatus_result()
9604 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9605 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9606 
    result.write(oprot)
9607 
    oprot.writeMessageEnd()
9608 
    oprot.trans.flush()
6094 rajveer 9609 
 
6159 rajveer 9610 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9611 
    args = getPlansForOperator_args()
9612 
    args.read(iprot)
9613 
    iprot.readMessageEnd()
9614 
    result = getPlansForOperator_result()
9615 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9616 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9617 
    result.write(oprot)
9618 
    oprot.writeMessageEnd()
9619 
    oprot.trans.flush()
6154 rajveer 9620 
 
6289 anupam.sin 9621 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9622 
    args = getRechargeDenominations_args()
9623 
    args.read(iprot)
9624 
    iprot.readMessageEnd()
9625 
    result = getRechargeDenominations_result()
9626 
    try:
6307 anupam.sin 9627 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9628 
    except TransactionServiceException, ex:
9629 
      result.ex = ex
9630 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9631 
    result.write(oprot)
9632 
    oprot.writeMessageEnd()
9633 
    oprot.trans.flush()
6159 rajveer 9634 
 
6371 rajveer 9635 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9636 
    args = updateAvailabilityStatus_args()
9637 
    args.read(iprot)
9638 
    iprot.readMessageEnd()
9639 
    result = updateAvailabilityStatus_result()
9640 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9641 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9642 
    result.write(oprot)
9643 
    oprot.writeMessageEnd()
9644 
    oprot.trans.flush()
6289 anupam.sin 9645 
 
6389 rajveer 9646 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9647 
    args = getAvailableEmiSchemes_args()
9648 
    args.read(iprot)
9649 
    iprot.readMessageEnd()
9650 
    result = getAvailableEmiSchemes_result()
9651 
    result.success = self._handler.getAvailableEmiSchemes()
9652 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9653 
    result.write(oprot)
9654 
    oprot.writeMessageEnd()
9655 
    oprot.trans.flush()
6371 rajveer 9656 
 
6389 rajveer 9657 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9658 
    args = getMiscCharges_args()
9659 
    args.read(iprot)
9660 
    iprot.readMessageEnd()
9661 
    result = getMiscCharges_result()
9662 
    result.success = self._handler.getMiscCharges(args.transactionId)
9663 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9664 
    result.write(oprot)
9665 
    oprot.writeMessageEnd()
9666 
    oprot.trans.flush()
9667 
 
6507 anupam.sin 9668 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9669 
    args = refundRechargeOrder_args()
9670 
    args.read(iprot)
9671 
    iprot.readMessageEnd()
9672 
    result = refundRechargeOrder_result()
9673 
    try:
9674 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9675 
    except TransactionServiceException, ex:
9676 
      result.ex = ex
9677 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9678 
    result.write(oprot)
9679 
    oprot.writeMessageEnd()
9680 
    oprot.trans.flush()
6389 rajveer 9681 
 
6821 amar.kumar 9682 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9683 
    args = getPhysicalOrders_args()
9684 
    args.read(iprot)
9685 
    iprot.readMessageEnd()
9686 
    result = getPhysicalOrders_result()
9687 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9688 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9689 
    result.write(oprot)
9690 
    oprot.writeMessageEnd()
9691 
    oprot.trans.flush()
6507 anupam.sin 9692 
 
6906 rajveer 9693 
  def process_getDocument(self, seqid, iprot, oprot):
9694 
    args = getDocument_args()
9695 
    args.read(iprot)
9696 
    iprot.readMessageEnd()
9697 
    result = getDocument_result()
9698 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9699 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9700 
    result.write(oprot)
9701 
    oprot.writeMessageEnd()
9702 
    oprot.trans.flush()
6821 amar.kumar 9703 
 
6985 anupam.sin 9704 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9705 
    args = changeShippingAddress_args()
9706 
    args.read(iprot)
9707 
    iprot.readMessageEnd()
9708 
    result = changeShippingAddress_result()
9709 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9710 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9711 
    result.write(oprot)
9712 
    oprot.writeMessageEnd()
9713 
    oprot.trans.flush()
6906 rajveer 9714 
 
6988 rajveer 9715 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9716 
    args = retrieveInvoice_args()
9717 
    args.read(iprot)
9718 
    iprot.readMessageEnd()
9719 
    result = retrieveInvoice_result()
7075 rajveer 9720 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9721 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9722 
    result.write(oprot)
9723 
    oprot.writeMessageEnd()
9724 
    oprot.trans.flush()
6985 anupam.sin 9725 
 
7026 rajveer 9726 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9727 
    args = receiveUpdatesForRedExpress_args()
9728 
    args.read(iprot)
9729 
    iprot.readMessageEnd()
9730 
    result = receiveUpdatesForRedExpress_result()
9731 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9732 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9733 
    result.write(oprot)
9734 
    oprot.writeMessageEnd()
9735 
    oprot.trans.flush()
6988 rajveer 9736 
 
7073 anupam.sin 9737 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9738 
    args = createRechargeTransaction_args()
9739 
    args.read(iprot)
9740 
    iprot.readMessageEnd()
9741 
    result = createRechargeTransaction_result()
9742 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9743 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9744 
    result.write(oprot)
9745 
    oprot.writeMessageEnd()
9746 
    oprot.trans.flush()
7026 rajveer 9747 
 
7085 rajveer 9748 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9749 
    args = getRechargeTransactions_args()
9750 
    args.read(iprot)
9751 
    iprot.readMessageEnd()
9752 
    result = getRechargeTransactions_result()
9753 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9754 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9755 
    result.write(oprot)
9756 
    oprot.writeMessageEnd()
9757 
    oprot.trans.flush()
9758 
 
7151 amit.gupta 9759 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9760 
    args = getRechargeTrans_args()
9761 
    args.read(iprot)
9762 
    iprot.readMessageEnd()
9763 
    result = getRechargeTrans_result()
9764 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9765 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9766 
    result.write(oprot)
9767 
    oprot.writeMessageEnd()
9768 
    oprot.trans.flush()
9769 
 
7080 anupam.sin 9770 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9771 
    args = getRechargeTransaction_args()
9772 
    args.read(iprot)
9773 
    iprot.readMessageEnd()
9774 
    result = getRechargeTransaction_result()
9775 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9776 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9777 
    result.write(oprot)
9778 
    oprot.writeMessageEnd()
9779 
    oprot.trans.flush()
7073 anupam.sin 9780 
 
7080 anupam.sin 9781 
  def process_getFRCs(self, seqid, iprot, oprot):
9782 
    args = getFRCs_args()
9783 
    args.read(iprot)
9784 
    iprot.readMessageEnd()
9785 
    result = getFRCs_result()
9786 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9787 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9788 
    result.write(oprot)
9789 
    oprot.writeMessageEnd()
9790 
    oprot.trans.flush()
9791 
 
7096 anupam.sin 9792 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9793 
    args = getHotspotStore_args()
9794 
    args.read(iprot)
9795 
    iprot.readMessageEnd()
9796 
    result = getHotspotStore_result()
9797 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9798 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9799 
    result.write(oprot)
9800 
    oprot.writeMessageEnd()
9801 
    oprot.trans.flush()
7080 anupam.sin 9802 
 
7096 anupam.sin 9803 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9804 
    args = getTelecomCircle_args()
9805 
    args.read(iprot)
9806 
    iprot.readMessageEnd()
9807 
    result = getTelecomCircle_result()
9808 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9809 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9810 
    result.write(oprot)
9811 
    oprot.writeMessageEnd()
9812 
    oprot.trans.flush()
9813 
 
7109 anupam.sin 9814 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9815 
    args = retrieveHotspotRechargeInvoice_args()
9816 
    args.read(iprot)
9817 
    iprot.readMessageEnd()
9818 
    result = retrieveHotspotRechargeInvoice_result()
9819 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9820 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9821 
    result.write(oprot)
9822 
    oprot.writeMessageEnd()
9823 
    oprot.trans.flush()
7096 anupam.sin 9824 
 
7190 amar.kumar 9825 
  def process_splitFreebieOrder(self, seqid, iprot, oprot):
9826 
    args = splitFreebieOrder_args()
9827 
    args.read(iprot)
9828 
    iprot.readMessageEnd()
9829 
    result = splitFreebieOrder_result()
9830 
    result.success = self._handler.splitFreebieOrder(args.orderId, args.splitReason, args.shippingDate)
9831 
    oprot.writeMessageBegin("splitFreebieOrder", TMessageType.REPLY, seqid)
9832 
    result.write(oprot)
9833 
    oprot.writeMessageEnd()
9834 
    oprot.trans.flush()
9835 
 
7169 anupam.sin 9836 
  def process_getRechargeTransactionsByNumber(self, seqid, iprot, oprot):
9837 
    args = getRechargeTransactionsByNumber_args()
9838 
    args.read(iprot)
9839 
    iprot.readMessageEnd()
9840 
    result = getRechargeTransactionsByNumber_result()
7172 anupam.sin 9841 
    result.success = self._handler.getRechargeTransactionsByNumber(args.number, args.storeId)
7169 anupam.sin 9842 
    oprot.writeMessageBegin("getRechargeTransactionsByNumber", TMessageType.REPLY, seqid)
9843 
    result.write(oprot)
9844 
    oprot.writeMessageEnd()
9845 
    oprot.trans.flush()
7109 anupam.sin 9846 
 
7169 anupam.sin 9847 
  def process_updateHotspotStorePassword(self, seqid, iprot, oprot):
9848 
    args = updateHotspotStorePassword_args()
9849 
    args.read(iprot)
9850 
    iprot.readMessageEnd()
9851 
    result = updateHotspotStorePassword_result()
9852 
    result.success = self._handler.updateHotspotStorePassword(args.storeId, args.password)
9853 
    oprot.writeMessageBegin("updateHotspotStorePassword", TMessageType.REPLY, seqid)
9854 
    result.write(oprot)
9855 
    oprot.writeMessageEnd()
9856 
    oprot.trans.flush()
9857 
 
7285 rajveer 9858 
  def process_topupCompanyWallet(self, seqid, iprot, oprot):
9859 
    args = topupCompanyWallet_args()
7263 anupam.sin 9860 
    args.read(iprot)
9861 
    iprot.readMessageEnd()
7285 rajveer 9862 
    result = topupCompanyWallet_result()
9863 
    result.success = self._handler.topupCompanyWallet(args.companyId, args.amount)
9864 
    oprot.writeMessageBegin("topupCompanyWallet", TMessageType.REPLY, seqid)
7263 anupam.sin 9865 
    result.write(oprot)
9866 
    oprot.writeMessageEnd()
9867 
    oprot.trans.flush()
7169 anupam.sin 9868 
 
7285 rajveer 9869 
  def process_getWalletBalanceForCompany(self, seqid, iprot, oprot):
9870 
    args = getWalletBalanceForCompany_args()
7267 anupam.sin 9871 
    args.read(iprot)
9872 
    iprot.readMessageEnd()
7285 rajveer 9873 
    result = getWalletBalanceForCompany_result()
9874 
    result.success = self._handler.getWalletBalanceForCompany(args.companyId)
9875 
    oprot.writeMessageBegin("getWalletBalanceForCompany", TMessageType.REPLY, seqid)
7267 anupam.sin 9876 
    result.write(oprot)
9877 
    oprot.writeMessageEnd()
9878 
    oprot.trans.flush()
7263 anupam.sin 9879 
 
7285 rajveer 9880 
  def process_getSourceDetail(self, seqid, iprot, oprot):
9881 
    args = getSourceDetail_args()
7267 anupam.sin 9882 
    args.read(iprot)
9883 
    iprot.readMessageEnd()
7285 rajveer 9884 
    result = getSourceDetail_result()
9885 
    result.success = self._handler.getSourceDetail(args.source)
9886 
    oprot.writeMessageBegin("getSourceDetail", TMessageType.REPLY, seqid)
7267 anupam.sin 9887 
    result.write(oprot)
9888 
    oprot.writeMessageEnd()
9889 
    oprot.trans.flush()
9890 
 
7308 rajveer 9891 
  def process_getAllCircles(self, seqid, iprot, oprot):
9892 
    args = getAllCircles_args()
9893 
    args.read(iprot)
9894 
    iprot.readMessageEnd()
9895 
    result = getAllCircles_result()
9896 
    result.success = self._handler.getAllCircles()
9897 
    oprot.writeMessageBegin("getAllCircles", TMessageType.REPLY, seqid)
9898 
    result.write(oprot)
9899 
    oprot.writeMessageEnd()
9900 
    oprot.trans.flush()
7267 anupam.sin 9901 
 
7308 rajveer 9902 
  def process_deleteFrcs(self, seqid, iprot, oprot):
9903 
    args = deleteFrcs_args()
9904 
    args.read(iprot)
9905 
    iprot.readMessageEnd()
9906 
    result = deleteFrcs_result()
9907 
    result.success = self._handler.deleteFrcs(args.frcIdsToDelete)
9908 
    oprot.writeMessageBegin("deleteFrcs", TMessageType.REPLY, seqid)
9909 
    result.write(oprot)
9910 
    oprot.writeMessageEnd()
9911 
    oprot.trans.flush()
9912 
 
7311 kshitij.so 9913 
  def process_addAmazonOrder(self, seqid, iprot, oprot):
9914 
    args = addAmazonOrder_args()
9915 
    args.read(iprot)
9916 
    iprot.readMessageEnd()
9917 
    result = addAmazonOrder_result()
9918 
    self._handler.addAmazonOrder(args.amazonOrder)
9919 
    oprot.writeMessageBegin("addAmazonOrder", TMessageType.REPLY, seqid)
9920 
    result.write(oprot)
9921 
    oprot.writeMessageEnd()
9922 
    oprot.trans.flush()
7308 rajveer 9923 
 
7322 vikram.rag 9924 
  def process_updateAmazonOrderStatus(self, seqid, iprot, oprot):
9925 
    args = updateAmazonOrderStatus_args()
7311 kshitij.so 9926 
    args.read(iprot)
9927 
    iprot.readMessageEnd()
7322 vikram.rag 9928 
    result = updateAmazonOrderStatus_result()
9929 
    result.success = self._handler.updateAmazonOrderStatus(args.orderId, args.status)
9930 
    oprot.writeMessageBegin("updateAmazonOrderStatus", TMessageType.REPLY, seqid)
7311 kshitij.so 9931 
    result.write(oprot)
9932 
    oprot.writeMessageEnd()
9933 
    oprot.trans.flush()
9934 
 
9935 
  def process_getAmazonOrdersShipped(self, seqid, iprot, oprot):
9936 
    args = getAmazonOrdersShipped_args()
9937 
    args.read(iprot)
9938 
    iprot.readMessageEnd()
9939 
    result = getAmazonOrdersShipped_result()
9940 
    result.success = self._handler.getAmazonOrdersShipped(args.interval)
9941 
    oprot.writeMessageBegin("getAmazonOrdersShipped", TMessageType.REPLY, seqid)
9942 
    result.write(oprot)
9943 
    oprot.writeMessageEnd()
9944 
    oprot.trans.flush()
9945 
 
9946 
  def process_getAmazonOrdersCancelled(self, seqid, iprot, oprot):
9947 
    args = getAmazonOrdersCancelled_args()
9948 
    args.read(iprot)
9949 
    iprot.readMessageEnd()
9950 
    result = getAmazonOrdersCancelled_result()
9951 
    result.success = self._handler.getAmazonOrdersCancelled(args.interval)
9952 
    oprot.writeMessageBegin("getAmazonOrdersCancelled", TMessageType.REPLY, seqid)
9953 
    result.write(oprot)
9954 
    oprot.writeMessageEnd()
9955 
    oprot.trans.flush()
9956 
 
7322 vikram.rag 9957 
  def process_getAmazonOrder(self, seqid, iprot, oprot):
9958 
    args = getAmazonOrder_args()
9959 
    args.read(iprot)
9960 
    iprot.readMessageEnd()
9961 
    result = getAmazonOrder_result()
9962 
    result.success = self._handler.getAmazonOrder(args.orderId)
9963 
    oprot.writeMessageBegin("getAmazonOrder", TMessageType.REPLY, seqid)
9964 
    result.write(oprot)
9965 
    oprot.writeMessageEnd()
9966 
    oprot.trans.flush()
7311 kshitij.so 9967 
 
7322 vikram.rag 9968 
 
94 ashish 9969 
# HELPER FUNCTIONS AND STRUCTURES
9970 
 
9971 
class createTransaction_args:
9972 
  """
9973 
  Attributes:
9974 
   - transaction
9975 
  """
9976 
 
9977 
  thrift_spec = (
9978 
    None, # 0
9979 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9980 
  )
9981 
 
9982 
  def __init__(self, transaction=None,):
9983 
    self.transaction = transaction
9984 
 
9985 
  def read(self, iprot):
9986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9988 
      return
9989 
    iprot.readStructBegin()
9990 
    while True:
9991 
      (fname, ftype, fid) = iprot.readFieldBegin()
9992 
      if ftype == TType.STOP:
9993 
        break
9994 
      if fid == 1:
9995 
        if ftype == TType.STRUCT:
9996 
          self.transaction = Transaction()
9997 
          self.transaction.read(iprot)
9998 
        else:
9999 
          iprot.skip(ftype)
10000 
      else:
10001 
        iprot.skip(ftype)
10002 
      iprot.readFieldEnd()
10003 
    iprot.readStructEnd()
10004 
 
10005 
  def write(self, oprot):
10006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10008 
      return
10009 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 10010 
    if self.transaction is not None:
94 ashish 10011 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
10012 
      self.transaction.write(oprot)
10013 
      oprot.writeFieldEnd()
10014 
    oprot.writeFieldStop()
10015 
    oprot.writeStructEnd()
10016 
 
3431 rajveer 10017 
  def validate(self):
10018 
    return
10019 
 
10020 
 
94 ashish 10021 
  def __repr__(self):
10022 
    L = ['%s=%r' % (key, value)
10023 
      for key, value in self.__dict__.iteritems()]
10024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10025 
 
10026 
  def __eq__(self, other):
10027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10028 
 
10029 
  def __ne__(self, other):
10030 
    return not (self == other)
10031 
 
10032 
class createTransaction_result:
10033 
  """
10034 
  Attributes:
132 ashish 10035 
   - success
94 ashish 10036 
   - ex
10037 
  """
10038 
 
10039 
  thrift_spec = (
132 ashish 10040 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10042 
  )
10043 
 
132 ashish 10044 
  def __init__(self, success=None, ex=None,):
10045 
    self.success = success
94 ashish 10046 
    self.ex = ex
10047 
 
10048 
  def read(self, iprot):
10049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10051 
      return
10052 
    iprot.readStructBegin()
10053 
    while True:
10054 
      (fname, ftype, fid) = iprot.readFieldBegin()
10055 
      if ftype == TType.STOP:
10056 
        break
132 ashish 10057 
      if fid == 0:
10058 
        if ftype == TType.I64:
10059 
          self.success = iprot.readI64();
10060 
        else:
10061 
          iprot.skip(ftype)
10062 
      elif fid == 1:
94 ashish 10063 
        if ftype == TType.STRUCT:
10064 
          self.ex = TransactionServiceException()
10065 
          self.ex.read(iprot)
10066 
        else:
10067 
          iprot.skip(ftype)
10068 
      else:
10069 
        iprot.skip(ftype)
10070 
      iprot.readFieldEnd()
10071 
    iprot.readStructEnd()
10072 
 
10073 
  def write(self, oprot):
10074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10076 
      return
10077 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 10078 
    if self.success is not None:
132 ashish 10079 
      oprot.writeFieldBegin('success', TType.I64, 0)
10080 
      oprot.writeI64(self.success)
10081 
      oprot.writeFieldEnd()
3431 rajveer 10082 
    if self.ex is not None:
94 ashish 10083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10084 
      self.ex.write(oprot)
10085 
      oprot.writeFieldEnd()
10086 
    oprot.writeFieldStop()
10087 
    oprot.writeStructEnd()
10088 
 
3431 rajveer 10089 
  def validate(self):
10090 
    return
10091 
 
10092 
 
94 ashish 10093 
  def __repr__(self):
10094 
    L = ['%s=%r' % (key, value)
10095 
      for key, value in self.__dict__.iteritems()]
10096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10097 
 
10098 
  def __eq__(self, other):
10099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10100 
 
10101 
  def __ne__(self, other):
10102 
    return not (self == other)
10103 
 
10104 
class getTransaction_args:
10105 
  """
10106 
  Attributes:
10107 
   - id
10108 
  """
10109 
 
10110 
  thrift_spec = (
10111 
    None, # 0
10112 
    (1, TType.I64, 'id', None, None, ), # 1
10113 
  )
10114 
 
10115 
  def __init__(self, id=None,):
10116 
    self.id = id
10117 
 
10118 
  def read(self, iprot):
10119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10121 
      return
10122 
    iprot.readStructBegin()
10123 
    while True:
10124 
      (fname, ftype, fid) = iprot.readFieldBegin()
10125 
      if ftype == TType.STOP:
10126 
        break
10127 
      if fid == 1:
10128 
        if ftype == TType.I64:
10129 
          self.id = iprot.readI64();
10130 
        else:
10131 
          iprot.skip(ftype)
10132 
      else:
10133 
        iprot.skip(ftype)
10134 
      iprot.readFieldEnd()
10135 
    iprot.readStructEnd()
10136 
 
10137 
  def write(self, oprot):
10138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10140 
      return
10141 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 10142 
    if self.id is not None:
94 ashish 10143 
      oprot.writeFieldBegin('id', TType.I64, 1)
10144 
      oprot.writeI64(self.id)
10145 
      oprot.writeFieldEnd()
10146 
    oprot.writeFieldStop()
10147 
    oprot.writeStructEnd()
10148 
 
3431 rajveer 10149 
  def validate(self):
10150 
    return
10151 
 
10152 
 
94 ashish 10153 
  def __repr__(self):
10154 
    L = ['%s=%r' % (key, value)
10155 
      for key, value in self.__dict__.iteritems()]
10156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10157 
 
10158 
  def __eq__(self, other):
10159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10160 
 
10161 
  def __ne__(self, other):
10162 
    return not (self == other)
10163 
 
10164 
class getTransaction_result:
10165 
  """
10166 
  Attributes:
10167 
   - success
10168 
   - ex
10169 
  """
10170 
 
10171 
  thrift_spec = (
10172 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
10173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10174 
  )
10175 
 
10176 
  def __init__(self, success=None, ex=None,):
10177 
    self.success = success
10178 
    self.ex = ex
10179 
 
10180 
  def read(self, iprot):
10181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10183 
      return
10184 
    iprot.readStructBegin()
10185 
    while True:
10186 
      (fname, ftype, fid) = iprot.readFieldBegin()
10187 
      if ftype == TType.STOP:
10188 
        break
10189 
      if fid == 0:
10190 
        if ftype == TType.STRUCT:
10191 
          self.success = Transaction()
10192 
          self.success.read(iprot)
10193 
        else:
10194 
          iprot.skip(ftype)
10195 
      elif fid == 1:
10196 
        if ftype == TType.STRUCT:
10197 
          self.ex = TransactionServiceException()
10198 
          self.ex.read(iprot)
10199 
        else:
10200 
          iprot.skip(ftype)
10201 
      else:
10202 
        iprot.skip(ftype)
10203 
      iprot.readFieldEnd()
10204 
    iprot.readStructEnd()
10205 
 
10206 
  def write(self, oprot):
10207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10209 
      return
10210 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 10211 
    if self.success is not None:
94 ashish 10212 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10213 
      self.success.write(oprot)
10214 
      oprot.writeFieldEnd()
3431 rajveer 10215 
    if self.ex is not None:
94 ashish 10216 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10217 
      self.ex.write(oprot)
10218 
      oprot.writeFieldEnd()
10219 
    oprot.writeFieldStop()
10220 
    oprot.writeStructEnd()
10221 
 
3431 rajveer 10222 
  def validate(self):
10223 
    return
10224 
 
10225 
 
94 ashish 10226 
  def __repr__(self):
10227 
    L = ['%s=%r' % (key, value)
10228 
      for key, value in self.__dict__.iteritems()]
10229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10230 
 
10231 
  def __eq__(self, other):
10232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10233 
 
10234 
  def __ne__(self, other):
10235 
    return not (self == other)
10236 
 
10237 
class getTransactionsForCustomer_args:
10238 
  """
10239 
  Attributes:
10240 
   - customerId
10241 
   - from_date
10242 
   - to_date
10243 
   - status
10244 
  """
10245 
 
10246 
  thrift_spec = (
10247 
    None, # 0
10248 
    (1, TType.I64, 'customerId', None, None, ), # 1
10249 
    (2, TType.I64, 'from_date', None, None, ), # 2
10250 
    (3, TType.I64, 'to_date', None, None, ), # 3
10251 
    (4, TType.I32, 'status', None, None, ), # 4
10252 
  )
10253 
 
10254 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
10255 
    self.customerId = customerId
10256 
    self.from_date = from_date
10257 
    self.to_date = to_date
10258 
    self.status = status
10259 
 
10260 
  def read(self, iprot):
10261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10263 
      return
10264 
    iprot.readStructBegin()
10265 
    while True:
10266 
      (fname, ftype, fid) = iprot.readFieldBegin()
10267 
      if ftype == TType.STOP:
10268 
        break
10269 
      if fid == 1:
10270 
        if ftype == TType.I64:
10271 
          self.customerId = iprot.readI64();
10272 
        else:
10273 
          iprot.skip(ftype)
10274 
      elif fid == 2:
10275 
        if ftype == TType.I64:
10276 
          self.from_date = iprot.readI64();
10277 
        else:
10278 
          iprot.skip(ftype)
10279 
      elif fid == 3:
10280 
        if ftype == TType.I64:
10281 
          self.to_date = iprot.readI64();
10282 
        else:
10283 
          iprot.skip(ftype)
10284 
      elif fid == 4:
10285 
        if ftype == TType.I32:
10286 
          self.status = iprot.readI32();
10287 
        else:
10288 
          iprot.skip(ftype)
10289 
      else:
10290 
        iprot.skip(ftype)
10291 
      iprot.readFieldEnd()
10292 
    iprot.readStructEnd()
10293 
 
10294 
  def write(self, oprot):
10295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10297 
      return
10298 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 10299 
    if self.customerId is not None:
94 ashish 10300 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10301 
      oprot.writeI64(self.customerId)
10302 
      oprot.writeFieldEnd()
3431 rajveer 10303 
    if self.from_date is not None:
94 ashish 10304 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10305 
      oprot.writeI64(self.from_date)
10306 
      oprot.writeFieldEnd()
3431 rajveer 10307 
    if self.to_date is not None:
94 ashish 10308 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10309 
      oprot.writeI64(self.to_date)
10310 
      oprot.writeFieldEnd()
3431 rajveer 10311 
    if self.status is not None:
94 ashish 10312 
      oprot.writeFieldBegin('status', TType.I32, 4)
10313 
      oprot.writeI32(self.status)
10314 
      oprot.writeFieldEnd()
10315 
    oprot.writeFieldStop()
10316 
    oprot.writeStructEnd()
10317 
 
3431 rajveer 10318 
  def validate(self):
10319 
    return
10320 
 
10321 
 
94 ashish 10322 
  def __repr__(self):
10323 
    L = ['%s=%r' % (key, value)
10324 
      for key, value in self.__dict__.iteritems()]
10325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10326 
 
10327 
  def __eq__(self, other):
10328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10329 
 
10330 
  def __ne__(self, other):
10331 
    return not (self == other)
10332 
 
10333 
class getTransactionsForCustomer_result:
10334 
  """
10335 
  Attributes:
10336 
   - success
10337 
   - ex
10338 
  """
10339 
 
10340 
  thrift_spec = (
10341 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10343 
  )
10344 
 
10345 
  def __init__(self, success=None, ex=None,):
10346 
    self.success = success
10347 
    self.ex = ex
10348 
 
10349 
  def read(self, iprot):
10350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10352 
      return
10353 
    iprot.readStructBegin()
10354 
    while True:
10355 
      (fname, ftype, fid) = iprot.readFieldBegin()
10356 
      if ftype == TType.STOP:
10357 
        break
10358 
      if fid == 0:
10359 
        if ftype == TType.LIST:
10360 
          self.success = []
6188 rajveer 10361 
          (_etype109, _size106) = iprot.readListBegin()
10362 
          for _i110 in xrange(_size106):
10363 
            _elem111 = Transaction()
10364 
            _elem111.read(iprot)
10365 
            self.success.append(_elem111)
94 ashish 10366 
          iprot.readListEnd()
10367 
        else:
10368 
          iprot.skip(ftype)
10369 
      elif fid == 1:
10370 
        if ftype == TType.STRUCT:
10371 
          self.ex = TransactionServiceException()
10372 
          self.ex.read(iprot)
10373 
        else:
10374 
          iprot.skip(ftype)
10375 
      else:
10376 
        iprot.skip(ftype)
10377 
      iprot.readFieldEnd()
10378 
    iprot.readStructEnd()
10379 
 
10380 
  def write(self, oprot):
10381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10383 
      return
10384 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 10385 
    if self.success is not None:
94 ashish 10386 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10387 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10388 
      for iter112 in self.success:
10389 
        iter112.write(oprot)
94 ashish 10390 
      oprot.writeListEnd()
10391 
      oprot.writeFieldEnd()
3431 rajveer 10392 
    if self.ex is not None:
94 ashish 10393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10394 
      self.ex.write(oprot)
10395 
      oprot.writeFieldEnd()
10396 
    oprot.writeFieldStop()
10397 
    oprot.writeStructEnd()
10398 
 
3431 rajveer 10399 
  def validate(self):
10400 
    return
10401 
 
10402 
 
94 ashish 10403 
  def __repr__(self):
10404 
    L = ['%s=%r' % (key, value)
10405 
      for key, value in self.__dict__.iteritems()]
10406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10407 
 
10408 
  def __eq__(self, other):
10409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10410 
 
10411 
  def __ne__(self, other):
10412 
    return not (self == other)
10413 
 
132 ashish 10414 
class getTransactionsForShoppingCartId_args:
10415 
  """
10416 
  Attributes:
10417 
   - shoppingCartId
10418 
  """
10419 
 
10420 
  thrift_spec = (
10421 
    None, # 0
10422 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
10423 
  )
10424 
 
10425 
  def __init__(self, shoppingCartId=None,):
10426 
    self.shoppingCartId = shoppingCartId
10427 
 
10428 
  def read(self, iprot):
10429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10431 
      return
10432 
    iprot.readStructBegin()
10433 
    while True:
10434 
      (fname, ftype, fid) = iprot.readFieldBegin()
10435 
      if ftype == TType.STOP:
10436 
        break
10437 
      if fid == 1:
10438 
        if ftype == TType.I64:
10439 
          self.shoppingCartId = iprot.readI64();
10440 
        else:
10441 
          iprot.skip(ftype)
10442 
      else:
10443 
        iprot.skip(ftype)
10444 
      iprot.readFieldEnd()
10445 
    iprot.readStructEnd()
10446 
 
10447 
  def write(self, oprot):
10448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10450 
      return
10451 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 10452 
    if self.shoppingCartId is not None:
132 ashish 10453 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
10454 
      oprot.writeI64(self.shoppingCartId)
10455 
      oprot.writeFieldEnd()
10456 
    oprot.writeFieldStop()
10457 
    oprot.writeStructEnd()
10458 
 
3431 rajveer 10459 
  def validate(self):
10460 
    return
10461 
 
10462 
 
132 ashish 10463 
  def __repr__(self):
10464 
    L = ['%s=%r' % (key, value)
10465 
      for key, value in self.__dict__.iteritems()]
10466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10467 
 
10468 
  def __eq__(self, other):
10469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10470 
 
10471 
  def __ne__(self, other):
10472 
    return not (self == other)
10473 
 
10474 
class getTransactionsForShoppingCartId_result:
10475 
  """
10476 
  Attributes:
10477 
   - success
10478 
   - ex
10479 
  """
10480 
 
10481 
  thrift_spec = (
10482 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10483 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10484 
  )
10485 
 
10486 
  def __init__(self, success=None, ex=None,):
10487 
    self.success = success
10488 
    self.ex = ex
10489 
 
10490 
  def read(self, iprot):
10491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10493 
      return
10494 
    iprot.readStructBegin()
10495 
    while True:
10496 
      (fname, ftype, fid) = iprot.readFieldBegin()
10497 
      if ftype == TType.STOP:
10498 
        break
10499 
      if fid == 0:
10500 
        if ftype == TType.LIST:
10501 
          self.success = []
6188 rajveer 10502 
          (_etype116, _size113) = iprot.readListBegin()
10503 
          for _i117 in xrange(_size113):
10504 
            _elem118 = Transaction()
10505 
            _elem118.read(iprot)
10506 
            self.success.append(_elem118)
132 ashish 10507 
          iprot.readListEnd()
10508 
        else:
10509 
          iprot.skip(ftype)
10510 
      elif fid == 1:
10511 
        if ftype == TType.STRUCT:
10512 
          self.ex = TransactionServiceException()
10513 
          self.ex.read(iprot)
10514 
        else:
10515 
          iprot.skip(ftype)
10516 
      else:
10517 
        iprot.skip(ftype)
10518 
      iprot.readFieldEnd()
10519 
    iprot.readStructEnd()
10520 
 
10521 
  def write(self, oprot):
10522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10524 
      return
10525 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 10526 
    if self.success is not None:
132 ashish 10527 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10528 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10529 
      for iter119 in self.success:
10530 
        iter119.write(oprot)
132 ashish 10531 
      oprot.writeListEnd()
10532 
      oprot.writeFieldEnd()
3431 rajveer 10533 
    if self.ex is not None:
132 ashish 10534 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10535 
      self.ex.write(oprot)
10536 
      oprot.writeFieldEnd()
10537 
    oprot.writeFieldStop()
10538 
    oprot.writeStructEnd()
10539 
 
3431 rajveer 10540 
  def validate(self):
10541 
    return
10542 
 
10543 
 
132 ashish 10544 
  def __repr__(self):
10545 
    L = ['%s=%r' % (key, value)
10546 
      for key, value in self.__dict__.iteritems()]
10547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10548 
 
10549 
  def __eq__(self, other):
10550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10551 
 
10552 
  def __ne__(self, other):
10553 
    return not (self == other)
10554 
 
94 ashish 10555 
class getTransactionStatus_args:
10556 
  """
10557 
  Attributes:
10558 
   - transactionId
10559 
  """
10560 
 
10561 
  thrift_spec = (
10562 
    None, # 0
10563 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10564 
  )
10565 
 
10566 
  def __init__(self, transactionId=None,):
10567 
    self.transactionId = transactionId
10568 
 
10569 
  def read(self, iprot):
10570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10572 
      return
10573 
    iprot.readStructBegin()
10574 
    while True:
10575 
      (fname, ftype, fid) = iprot.readFieldBegin()
10576 
      if ftype == TType.STOP:
10577 
        break
10578 
      if fid == 1:
10579 
        if ftype == TType.I64:
10580 
          self.transactionId = iprot.readI64();
10581 
        else:
10582 
          iprot.skip(ftype)
10583 
      else:
10584 
        iprot.skip(ftype)
10585 
      iprot.readFieldEnd()
10586 
    iprot.readStructEnd()
10587 
 
10588 
  def write(self, oprot):
10589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10591 
      return
10592 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 10593 
    if self.transactionId is not None:
94 ashish 10594 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10595 
      oprot.writeI64(self.transactionId)
10596 
      oprot.writeFieldEnd()
10597 
    oprot.writeFieldStop()
10598 
    oprot.writeStructEnd()
10599 
 
3431 rajveer 10600 
  def validate(self):
10601 
    return
10602 
 
10603 
 
94 ashish 10604 
  def __repr__(self):
10605 
    L = ['%s=%r' % (key, value)
10606 
      for key, value in self.__dict__.iteritems()]
10607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10608 
 
10609 
  def __eq__(self, other):
10610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10611 
 
10612 
  def __ne__(self, other):
10613 
    return not (self == other)
10614 
 
10615 
class getTransactionStatus_result:
10616 
  """
10617 
  Attributes:
10618 
   - success
10619 
   - ex
10620 
  """
10621 
 
10622 
  thrift_spec = (
10623 
    (0, TType.I32, 'success', None, None, ), # 0
10624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10625 
  )
10626 
 
10627 
  def __init__(self, success=None, ex=None,):
10628 
    self.success = success
10629 
    self.ex = ex
10630 
 
10631 
  def read(self, iprot):
10632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10634 
      return
10635 
    iprot.readStructBegin()
10636 
    while True:
10637 
      (fname, ftype, fid) = iprot.readFieldBegin()
10638 
      if ftype == TType.STOP:
10639 
        break
10640 
      if fid == 0:
10641 
        if ftype == TType.I32:
10642 
          self.success = iprot.readI32();
10643 
        else:
10644 
          iprot.skip(ftype)
10645 
      elif fid == 1:
10646 
        if ftype == TType.STRUCT:
10647 
          self.ex = TransactionServiceException()
10648 
          self.ex.read(iprot)
10649 
        else:
10650 
          iprot.skip(ftype)
10651 
      else:
10652 
        iprot.skip(ftype)
10653 
      iprot.readFieldEnd()
10654 
    iprot.readStructEnd()
10655 
 
10656 
  def write(self, oprot):
10657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10659 
      return
10660 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10661 
    if self.success is not None:
94 ashish 10662 
      oprot.writeFieldBegin('success', TType.I32, 0)
10663 
      oprot.writeI32(self.success)
10664 
      oprot.writeFieldEnd()
3431 rajveer 10665 
    if self.ex is not None:
94 ashish 10666 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10667 
      self.ex.write(oprot)
10668 
      oprot.writeFieldEnd()
10669 
    oprot.writeFieldStop()
10670 
    oprot.writeStructEnd()
10671 
 
3431 rajveer 10672 
  def validate(self):
10673 
    return
10674 
 
10675 
 
94 ashish 10676 
  def __repr__(self):
10677 
    L = ['%s=%r' % (key, value)
10678 
      for key, value in self.__dict__.iteritems()]
10679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10680 
 
10681 
  def __eq__(self, other):
10682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10683 
 
10684 
  def __ne__(self, other):
10685 
    return not (self == other)
10686 
 
10687 
class changeTransactionStatus_args:
10688 
  """
10689 
  Attributes:
10690 
   - transactionId
10691 
   - status
10692 
   - description
5527 anupam.sin 10693 
   - pickUp
10694 
   - orderType
7293 anupam.sin 10695 
   - source
94 ashish 10696 
  """
10697 
 
10698 
  thrift_spec = (
10699 
    None, # 0
10700 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10701 
    (2, TType.I32, 'status', None, None, ), # 2
10702 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10703 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10704 
    (5, TType.I32, 'orderType', None, None, ), # 5
7293 anupam.sin 10705 
    (6, TType.I32, 'source', None, None, ), # 6
94 ashish 10706 
  )
10707 
 
7293 anupam.sin 10708 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None, source=None,):
94 ashish 10709 
    self.transactionId = transactionId
10710 
    self.status = status
10711 
    self.description = description
5527 anupam.sin 10712 
    self.pickUp = pickUp
10713 
    self.orderType = orderType
7293 anupam.sin 10714 
    self.source = source
94 ashish 10715 
 
10716 
  def read(self, iprot):
10717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10719 
      return
10720 
    iprot.readStructBegin()
10721 
    while True:
10722 
      (fname, ftype, fid) = iprot.readFieldBegin()
10723 
      if ftype == TType.STOP:
10724 
        break
10725 
      if fid == 1:
10726 
        if ftype == TType.I64:
10727 
          self.transactionId = iprot.readI64();
10728 
        else:
10729 
          iprot.skip(ftype)
10730 
      elif fid == 2:
10731 
        if ftype == TType.I32:
10732 
          self.status = iprot.readI32();
10733 
        else:
10734 
          iprot.skip(ftype)
10735 
      elif fid == 3:
10736 
        if ftype == TType.STRING:
10737 
          self.description = iprot.readString();
10738 
        else:
10739 
          iprot.skip(ftype)
5387 rajveer 10740 
      elif fid == 4:
5527 anupam.sin 10741 
        if ftype == TType.I64:
10742 
          self.pickUp = iprot.readI64();
5387 rajveer 10743 
        else:
10744 
          iprot.skip(ftype)
5527 anupam.sin 10745 
      elif fid == 5:
10746 
        if ftype == TType.I32:
10747 
          self.orderType = iprot.readI32();
10748 
        else:
10749 
          iprot.skip(ftype)
7293 anupam.sin 10750 
      elif fid == 6:
10751 
        if ftype == TType.I32:
10752 
          self.source = iprot.readI32();
10753 
        else:
10754 
          iprot.skip(ftype)
94 ashish 10755 
      else:
10756 
        iprot.skip(ftype)
10757 
      iprot.readFieldEnd()
10758 
    iprot.readStructEnd()
10759 
 
10760 
  def write(self, oprot):
10761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10763 
      return
10764 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10765 
    if self.transactionId is not None:
94 ashish 10766 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10767 
      oprot.writeI64(self.transactionId)
10768 
      oprot.writeFieldEnd()
3431 rajveer 10769 
    if self.status is not None:
94 ashish 10770 
      oprot.writeFieldBegin('status', TType.I32, 2)
10771 
      oprot.writeI32(self.status)
10772 
      oprot.writeFieldEnd()
3431 rajveer 10773 
    if self.description is not None:
94 ashish 10774 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10775 
      oprot.writeString(self.description)
10776 
      oprot.writeFieldEnd()
5527 anupam.sin 10777 
    if self.pickUp is not None:
10778 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10779 
      oprot.writeI64(self.pickUp)
5387 rajveer 10780 
      oprot.writeFieldEnd()
5527 anupam.sin 10781 
    if self.orderType is not None:
10782 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10783 
      oprot.writeI32(self.orderType)
10784 
      oprot.writeFieldEnd()
7293 anupam.sin 10785 
    if self.source is not None:
10786 
      oprot.writeFieldBegin('source', TType.I32, 6)
10787 
      oprot.writeI32(self.source)
10788 
      oprot.writeFieldEnd()
94 ashish 10789 
    oprot.writeFieldStop()
10790 
    oprot.writeStructEnd()
10791 
 
3431 rajveer 10792 
  def validate(self):
10793 
    return
10794 
 
10795 
 
94 ashish 10796 
  def __repr__(self):
10797 
    L = ['%s=%r' % (key, value)
10798 
      for key, value in self.__dict__.iteritems()]
10799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10800 
 
10801 
  def __eq__(self, other):
10802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10803 
 
10804 
  def __ne__(self, other):
10805 
    return not (self == other)
10806 
 
10807 
class changeTransactionStatus_result:
10808 
  """
10809 
  Attributes:
10810 
   - success
10811 
   - ex
10812 
  """
10813 
 
10814 
  thrift_spec = (
10815 
    (0, TType.BOOL, 'success', None, None, ), # 0
10816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10817 
  )
10818 
 
10819 
  def __init__(self, success=None, ex=None,):
10820 
    self.success = success
10821 
    self.ex = ex
10822 
 
10823 
  def read(self, iprot):
10824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10826 
      return
10827 
    iprot.readStructBegin()
10828 
    while True:
10829 
      (fname, ftype, fid) = iprot.readFieldBegin()
10830 
      if ftype == TType.STOP:
10831 
        break
10832 
      if fid == 0:
10833 
        if ftype == TType.BOOL:
10834 
          self.success = iprot.readBool();
10835 
        else:
10836 
          iprot.skip(ftype)
10837 
      elif fid == 1:
10838 
        if ftype == TType.STRUCT:
10839 
          self.ex = TransactionServiceException()
10840 
          self.ex.read(iprot)
10841 
        else:
10842 
          iprot.skip(ftype)
10843 
      else:
10844 
        iprot.skip(ftype)
10845 
      iprot.readFieldEnd()
10846 
    iprot.readStructEnd()
10847 
 
10848 
  def write(self, oprot):
10849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10851 
      return
10852 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 10853 
    if self.success is not None:
94 ashish 10854 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10855 
      oprot.writeBool(self.success)
10856 
      oprot.writeFieldEnd()
3431 rajveer 10857 
    if self.ex is not None:
94 ashish 10858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10859 
      self.ex.write(oprot)
10860 
      oprot.writeFieldEnd()
10861 
    oprot.writeFieldStop()
10862 
    oprot.writeStructEnd()
10863 
 
3431 rajveer 10864 
  def validate(self):
10865 
    return
10866 
 
10867 
 
94 ashish 10868 
  def __repr__(self):
10869 
    L = ['%s=%r' % (key, value)
10870 
      for key, value in self.__dict__.iteritems()]
10871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10872 
 
10873 
  def __eq__(self, other):
10874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10875 
 
10876 
  def __ne__(self, other):
10877 
    return not (self == other)
10878 
 
1398 varun.gupt 10879 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10880 
  """
10881 
  Attributes:
10882 
   - transactionId
10883 
  """
10884 
 
10885 
  thrift_spec = (
10886 
    None, # 0
10887 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10888 
  )
10889 
 
10890 
  def __init__(self, transactionId=None,):
10891 
    self.transactionId = transactionId
10892 
 
10893 
  def read(self, iprot):
10894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10896 
      return
10897 
    iprot.readStructBegin()
10898 
    while True:
10899 
      (fname, ftype, fid) = iprot.readFieldBegin()
10900 
      if ftype == TType.STOP:
10901 
        break
10902 
      if fid == 1:
10903 
        if ftype == TType.I64:
10904 
          self.transactionId = iprot.readI64();
10905 
        else:
10906 
          iprot.skip(ftype)
10907 
      else:
10908 
        iprot.skip(ftype)
10909 
      iprot.readFieldEnd()
10910 
    iprot.readStructEnd()
10911 
 
10912 
  def write(self, oprot):
10913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10915 
      return
1398 varun.gupt 10916 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10917 
    if self.transactionId is not None:
1382 varun.gupt 10918 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10919 
      oprot.writeI64(self.transactionId)
10920 
      oprot.writeFieldEnd()
10921 
    oprot.writeFieldStop()
10922 
    oprot.writeStructEnd()
10923 
 
3431 rajveer 10924 
  def validate(self):
10925 
    return
10926 
 
10927 
 
1382 varun.gupt 10928 
  def __repr__(self):
10929 
    L = ['%s=%r' % (key, value)
10930 
      for key, value in self.__dict__.iteritems()]
10931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10932 
 
10933 
  def __eq__(self, other):
10934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10935 
 
10936 
  def __ne__(self, other):
10937 
    return not (self == other)
10938 
 
1398 varun.gupt 10939 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10940 
  """
10941 
  Attributes:
10942 
   - success
10943 
   - ex
10944 
  """
10945 
 
10946 
  thrift_spec = (
10947 
    (0, TType.BOOL, 'success', None, None, ), # 0
10948 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10949 
  )
10950 
 
10951 
  def __init__(self, success=None, ex=None,):
10952 
    self.success = success
10953 
    self.ex = ex
10954 
 
10955 
  def read(self, iprot):
10956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10958 
      return
10959 
    iprot.readStructBegin()
10960 
    while True:
10961 
      (fname, ftype, fid) = iprot.readFieldBegin()
10962 
      if ftype == TType.STOP:
10963 
        break
10964 
      if fid == 0:
10965 
        if ftype == TType.BOOL:
10966 
          self.success = iprot.readBool();
10967 
        else:
10968 
          iprot.skip(ftype)
10969 
      elif fid == 1:
10970 
        if ftype == TType.STRUCT:
10971 
          self.ex = TransactionServiceException()
10972 
          self.ex.read(iprot)
10973 
        else:
10974 
          iprot.skip(ftype)
10975 
      else:
10976 
        iprot.skip(ftype)
10977 
      iprot.readFieldEnd()
10978 
    iprot.readStructEnd()
10979 
 
10980 
  def write(self, oprot):
10981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10983 
      return
1398 varun.gupt 10984 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10985 
    if self.success is not None:
1382 varun.gupt 10986 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10987 
      oprot.writeBool(self.success)
10988 
      oprot.writeFieldEnd()
3431 rajveer 10989 
    if self.ex is not None:
1382 varun.gupt 10990 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10991 
      self.ex.write(oprot)
10992 
      oprot.writeFieldEnd()
10993 
    oprot.writeFieldStop()
10994 
    oprot.writeStructEnd()
10995 
 
3431 rajveer 10996 
  def validate(self):
10997 
    return
10998 
 
10999 
 
1382 varun.gupt 11000 
  def __repr__(self):
11001 
    L = ['%s=%r' % (key, value)
11002 
      for key, value in self.__dict__.iteritems()]
11003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11004 
 
11005 
  def __eq__(self, other):
11006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11007 
 
11008 
  def __ne__(self, other):
11009 
    return not (self == other)
11010 
 
483 rajveer 11011 
class getAllOrders_args:
94 ashish 11012 
  """
11013 
  Attributes:
4801 anupam.sin 11014 
   - statuses
483 rajveer 11015 
   - from_date
11016 
   - to_date
11017 
   - warehouse_id
94 ashish 11018 
  """
11019 
 
11020 
  thrift_spec = (
11021 
    None, # 0
4801 anupam.sin 11022 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 11023 
    (2, TType.I64, 'from_date', None, None, ), # 2
11024 
    (3, TType.I64, 'to_date', None, None, ), # 3
11025 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 11026 
  )
11027 
 
4801 anupam.sin 11028 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
11029 
    self.statuses = statuses
483 rajveer 11030 
    self.from_date = from_date
11031 
    self.to_date = to_date
11032 
    self.warehouse_id = warehouse_id
94 ashish 11033 
 
11034 
  def read(self, iprot):
11035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11037 
      return
11038 
    iprot.readStructBegin()
11039 
    while True:
11040 
      (fname, ftype, fid) = iprot.readFieldBegin()
11041 
      if ftype == TType.STOP:
11042 
        break
11043 
      if fid == 1:
4801 anupam.sin 11044 
        if ftype == TType.LIST:
11045 
          self.statuses = []
6188 rajveer 11046 
          (_etype123, _size120) = iprot.readListBegin()
11047 
          for _i124 in xrange(_size120):
11048 
            _elem125 = iprot.readI32();
11049 
            self.statuses.append(_elem125)
4801 anupam.sin 11050 
          iprot.readListEnd()
94 ashish 11051 
        else:
11052 
          iprot.skip(ftype)
483 rajveer 11053 
      elif fid == 2:
11054 
        if ftype == TType.I64:
11055 
          self.from_date = iprot.readI64();
94 ashish 11056 
        else:
11057 
          iprot.skip(ftype)
483 rajveer 11058 
      elif fid == 3:
11059 
        if ftype == TType.I64:
11060 
          self.to_date = iprot.readI64();
94 ashish 11061 
        else:
11062 
          iprot.skip(ftype)
483 rajveer 11063 
      elif fid == 4:
94 ashish 11064 
        if ftype == TType.I64:
483 rajveer 11065 
          self.warehouse_id = iprot.readI64();
94 ashish 11066 
        else:
11067 
          iprot.skip(ftype)
11068 
      else:
11069 
        iprot.skip(ftype)
11070 
      iprot.readFieldEnd()
11071 
    iprot.readStructEnd()
11072 
 
11073 
  def write(self, oprot):
11074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11076 
      return
483 rajveer 11077 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 11078 
    if self.statuses is not None:
11079 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11080 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11081 
      for iter126 in self.statuses:
11082 
        oprot.writeI32(iter126)
4801 anupam.sin 11083 
      oprot.writeListEnd()
94 ashish 11084 
      oprot.writeFieldEnd()
3431 rajveer 11085 
    if self.from_date is not None:
483 rajveer 11086 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11087 
      oprot.writeI64(self.from_date)
94 ashish 11088 
      oprot.writeFieldEnd()
3431 rajveer 11089 
    if self.to_date is not None:
483 rajveer 11090 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11091 
      oprot.writeI64(self.to_date)
94 ashish 11092 
      oprot.writeFieldEnd()
3431 rajveer 11093 
    if self.warehouse_id is not None:
483 rajveer 11094 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11095 
      oprot.writeI64(self.warehouse_id)
94 ashish 11096 
      oprot.writeFieldEnd()
11097 
    oprot.writeFieldStop()
11098 
    oprot.writeStructEnd()
11099 
 
3431 rajveer 11100 
  def validate(self):
11101 
    return
11102 
 
11103 
 
94 ashish 11104 
  def __repr__(self):
11105 
    L = ['%s=%r' % (key, value)
11106 
      for key, value in self.__dict__.iteritems()]
11107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11108 
 
11109 
  def __eq__(self, other):
11110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11111 
 
11112 
  def __ne__(self, other):
11113 
    return not (self == other)
11114 
 
483 rajveer 11115 
class getAllOrders_result:
94 ashish 11116 
  """
11117 
  Attributes:
11118 
   - success
11119 
   - ex
11120 
  """
11121 
 
11122 
  thrift_spec = (
483 rajveer 11123 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 11124 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11125 
  )
11126 
 
11127 
  def __init__(self, success=None, ex=None,):
11128 
    self.success = success
11129 
    self.ex = ex
11130 
 
11131 
  def read(self, iprot):
11132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11134 
      return
11135 
    iprot.readStructBegin()
11136 
    while True:
11137 
      (fname, ftype, fid) = iprot.readFieldBegin()
11138 
      if ftype == TType.STOP:
11139 
        break
11140 
      if fid == 0:
483 rajveer 11141 
        if ftype == TType.LIST:
11142 
          self.success = []
6188 rajveer 11143 
          (_etype130, _size127) = iprot.readListBegin()
11144 
          for _i131 in xrange(_size127):
11145 
            _elem132 = Order()
11146 
            _elem132.read(iprot)
11147 
            self.success.append(_elem132)
483 rajveer 11148 
          iprot.readListEnd()
94 ashish 11149 
        else:
11150 
          iprot.skip(ftype)
11151 
      elif fid == 1:
11152 
        if ftype == TType.STRUCT:
11153 
          self.ex = TransactionServiceException()
11154 
          self.ex.read(iprot)
11155 
        else:
11156 
          iprot.skip(ftype)
11157 
      else:
11158 
        iprot.skip(ftype)
11159 
      iprot.readFieldEnd()
11160 
    iprot.readStructEnd()
11161 
 
11162 
  def write(self, oprot):
11163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11165 
      return
483 rajveer 11166 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 11167 
    if self.success is not None:
483 rajveer 11168 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11169 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11170 
      for iter133 in self.success:
11171 
        iter133.write(oprot)
483 rajveer 11172 
      oprot.writeListEnd()
94 ashish 11173 
      oprot.writeFieldEnd()
3431 rajveer 11174 
    if self.ex is not None:
94 ashish 11175 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11176 
      self.ex.write(oprot)
11177 
      oprot.writeFieldEnd()
11178 
    oprot.writeFieldStop()
11179 
    oprot.writeStructEnd()
11180 
 
3431 rajveer 11181 
  def validate(self):
11182 
    return
11183 
 
11184 
 
94 ashish 11185 
  def __repr__(self):
11186 
    L = ['%s=%r' % (key, value)
11187 
      for key, value in self.__dict__.iteritems()]
11188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11189 
 
11190 
  def __eq__(self, other):
11191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11192 
 
11193 
  def __ne__(self, other):
11194 
    return not (self == other)
11195 
 
4133 chandransh 11196 
class getOrdersInBatch_args:
11197 
  """
11198 
  Attributes:
11199 
   - statuses
11200 
   - offset
11201 
   - limit
11202 
   - warehouse_id
11203 
  """
11204 
 
11205 
  thrift_spec = (
11206 
    None, # 0
11207 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
11208 
    (2, TType.I64, 'offset', None, None, ), # 2
11209 
    (3, TType.I64, 'limit', None, None, ), # 3
11210 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11211 
  )
11212 
 
11213 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
11214 
    self.statuses = statuses
11215 
    self.offset = offset
11216 
    self.limit = limit
11217 
    self.warehouse_id = warehouse_id
11218 
 
11219 
  def read(self, iprot):
11220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11222 
      return
11223 
    iprot.readStructBegin()
11224 
    while True:
11225 
      (fname, ftype, fid) = iprot.readFieldBegin()
11226 
      if ftype == TType.STOP:
11227 
        break
11228 
      if fid == 1:
11229 
        if ftype == TType.LIST:
11230 
          self.statuses = []
6188 rajveer 11231 
          (_etype137, _size134) = iprot.readListBegin()
11232 
          for _i138 in xrange(_size134):
11233 
            _elem139 = iprot.readI32();
11234 
            self.statuses.append(_elem139)
4133 chandransh 11235 
          iprot.readListEnd()
11236 
        else:
11237 
          iprot.skip(ftype)
11238 
      elif fid == 2:
11239 
        if ftype == TType.I64:
11240 
          self.offset = iprot.readI64();
11241 
        else:
11242 
          iprot.skip(ftype)
11243 
      elif fid == 3:
11244 
        if ftype == TType.I64:
11245 
          self.limit = iprot.readI64();
11246 
        else:
11247 
          iprot.skip(ftype)
11248 
      elif fid == 4:
11249 
        if ftype == TType.I64:
11250 
          self.warehouse_id = iprot.readI64();
11251 
        else:
11252 
          iprot.skip(ftype)
11253 
      else:
11254 
        iprot.skip(ftype)
11255 
      iprot.readFieldEnd()
11256 
    iprot.readStructEnd()
11257 
 
11258 
  def write(self, oprot):
11259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11261 
      return
11262 
    oprot.writeStructBegin('getOrdersInBatch_args')
11263 
    if self.statuses is not None:
11264 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11265 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11266 
      for iter140 in self.statuses:
11267 
        oprot.writeI32(iter140)
4133 chandransh 11268 
      oprot.writeListEnd()
11269 
      oprot.writeFieldEnd()
11270 
    if self.offset is not None:
11271 
      oprot.writeFieldBegin('offset', TType.I64, 2)
11272 
      oprot.writeI64(self.offset)
11273 
      oprot.writeFieldEnd()
11274 
    if self.limit is not None:
11275 
      oprot.writeFieldBegin('limit', TType.I64, 3)
11276 
      oprot.writeI64(self.limit)
11277 
      oprot.writeFieldEnd()
11278 
    if self.warehouse_id is not None:
11279 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11280 
      oprot.writeI64(self.warehouse_id)
11281 
      oprot.writeFieldEnd()
11282 
    oprot.writeFieldStop()
11283 
    oprot.writeStructEnd()
11284 
 
11285 
  def validate(self):
11286 
    return
11287 
 
11288 
 
11289 
  def __repr__(self):
11290 
    L = ['%s=%r' % (key, value)
11291 
      for key, value in self.__dict__.iteritems()]
11292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11293 
 
11294 
  def __eq__(self, other):
11295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11296 
 
11297 
  def __ne__(self, other):
11298 
    return not (self == other)
11299 
 
11300 
class getOrdersInBatch_result:
11301 
  """
11302 
  Attributes:
11303 
   - success
11304 
   - ex
11305 
  """
11306 
 
11307 
  thrift_spec = (
11308 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11309 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11310 
  )
11311 
 
11312 
  def __init__(self, success=None, ex=None,):
11313 
    self.success = success
11314 
    self.ex = ex
11315 
 
11316 
  def read(self, iprot):
11317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11319 
      return
11320 
    iprot.readStructBegin()
11321 
    while True:
11322 
      (fname, ftype, fid) = iprot.readFieldBegin()
11323 
      if ftype == TType.STOP:
11324 
        break
11325 
      if fid == 0:
11326 
        if ftype == TType.LIST:
11327 
          self.success = []
6188 rajveer 11328 
          (_etype144, _size141) = iprot.readListBegin()
11329 
          for _i145 in xrange(_size141):
11330 
            _elem146 = Order()
11331 
            _elem146.read(iprot)
11332 
            self.success.append(_elem146)
4133 chandransh 11333 
          iprot.readListEnd()
11334 
        else:
11335 
          iprot.skip(ftype)
11336 
      elif fid == 1:
11337 
        if ftype == TType.STRUCT:
11338 
          self.ex = TransactionServiceException()
11339 
          self.ex.read(iprot)
11340 
        else:
11341 
          iprot.skip(ftype)
11342 
      else:
11343 
        iprot.skip(ftype)
11344 
      iprot.readFieldEnd()
11345 
    iprot.readStructEnd()
11346 
 
11347 
  def write(self, oprot):
11348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11350 
      return
11351 
    oprot.writeStructBegin('getOrdersInBatch_result')
11352 
    if self.success is not None:
11353 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11354 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11355 
      for iter147 in self.success:
11356 
        iter147.write(oprot)
4133 chandransh 11357 
      oprot.writeListEnd()
11358 
      oprot.writeFieldEnd()
11359 
    if self.ex is not None:
11360 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11361 
      self.ex.write(oprot)
11362 
      oprot.writeFieldEnd()
11363 
    oprot.writeFieldStop()
11364 
    oprot.writeStructEnd()
11365 
 
11366 
  def validate(self):
11367 
    return
11368 
 
11369 
 
11370 
  def __repr__(self):
11371 
    L = ['%s=%r' % (key, value)
11372 
      for key, value in self.__dict__.iteritems()]
11373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11374 
 
11375 
  def __eq__(self, other):
11376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11377 
 
11378 
  def __ne__(self, other):
11379 
    return not (self == other)
11380 
 
11381 
class getOrderCount_args:
11382 
  """
11383 
  Attributes:
11384 
   - statuses
11385 
   - warehouseId
11386 
  """
11387 
 
11388 
  thrift_spec = (
11389 
    None, # 0
11390 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
11391 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11392 
  )
11393 
 
11394 
  def __init__(self, statuses=None, warehouseId=None,):
11395 
    self.statuses = statuses
11396 
    self.warehouseId = warehouseId
11397 
 
11398 
  def read(self, iprot):
11399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11401 
      return
11402 
    iprot.readStructBegin()
11403 
    while True:
11404 
      (fname, ftype, fid) = iprot.readFieldBegin()
11405 
      if ftype == TType.STOP:
11406 
        break
11407 
      if fid == 1:
11408 
        if ftype == TType.LIST:
11409 
          self.statuses = []
6188 rajveer 11410 
          (_etype151, _size148) = iprot.readListBegin()
11411 
          for _i152 in xrange(_size148):
11412 
            _elem153 = iprot.readI32();
11413 
            self.statuses.append(_elem153)
4133 chandransh 11414 
          iprot.readListEnd()
11415 
        else:
11416 
          iprot.skip(ftype)
11417 
      elif fid == 2:
11418 
        if ftype == TType.I64:
11419 
          self.warehouseId = iprot.readI64();
11420 
        else:
11421 
          iprot.skip(ftype)
11422 
      else:
11423 
        iprot.skip(ftype)
11424 
      iprot.readFieldEnd()
11425 
    iprot.readStructEnd()
11426 
 
11427 
  def write(self, oprot):
11428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11430 
      return
11431 
    oprot.writeStructBegin('getOrderCount_args')
11432 
    if self.statuses is not None:
11433 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11434 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11435 
      for iter154 in self.statuses:
11436 
        oprot.writeI32(iter154)
4133 chandransh 11437 
      oprot.writeListEnd()
11438 
      oprot.writeFieldEnd()
11439 
    if self.warehouseId is not None:
11440 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11441 
      oprot.writeI64(self.warehouseId)
11442 
      oprot.writeFieldEnd()
11443 
    oprot.writeFieldStop()
11444 
    oprot.writeStructEnd()
11445 
 
11446 
  def validate(self):
11447 
    return
11448 
 
11449 
 
11450 
  def __repr__(self):
11451 
    L = ['%s=%r' % (key, value)
11452 
      for key, value in self.__dict__.iteritems()]
11453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11454 
 
11455 
  def __eq__(self, other):
11456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11457 
 
11458 
  def __ne__(self, other):
11459 
    return not (self == other)
11460 
 
11461 
class getOrderCount_result:
11462 
  """
11463 
  Attributes:
11464 
   - success
11465 
   - ex
11466 
  """
11467 
 
11468 
  thrift_spec = (
11469 
    (0, TType.I32, 'success', None, None, ), # 0
11470 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11471 
  )
11472 
 
11473 
  def __init__(self, success=None, ex=None,):
11474 
    self.success = success
11475 
    self.ex = ex
11476 
 
11477 
  def read(self, iprot):
11478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11480 
      return
11481 
    iprot.readStructBegin()
11482 
    while True:
11483 
      (fname, ftype, fid) = iprot.readFieldBegin()
11484 
      if ftype == TType.STOP:
11485 
        break
11486 
      if fid == 0:
11487 
        if ftype == TType.I32:
11488 
          self.success = iprot.readI32();
11489 
        else:
11490 
          iprot.skip(ftype)
11491 
      elif fid == 1:
11492 
        if ftype == TType.STRUCT:
11493 
          self.ex = TransactionServiceException()
11494 
          self.ex.read(iprot)
11495 
        else:
11496 
          iprot.skip(ftype)
11497 
      else:
11498 
        iprot.skip(ftype)
11499 
      iprot.readFieldEnd()
11500 
    iprot.readStructEnd()
11501 
 
11502 
  def write(self, oprot):
11503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11505 
      return
11506 
    oprot.writeStructBegin('getOrderCount_result')
11507 
    if self.success is not None:
11508 
      oprot.writeFieldBegin('success', TType.I32, 0)
11509 
      oprot.writeI32(self.success)
11510 
      oprot.writeFieldEnd()
11511 
    if self.ex is not None:
11512 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11513 
      self.ex.write(oprot)
11514 
      oprot.writeFieldEnd()
11515 
    oprot.writeFieldStop()
11516 
    oprot.writeStructEnd()
11517 
 
11518 
  def validate(self):
11519 
    return
11520 
 
11521 
 
11522 
  def __repr__(self):
11523 
    L = ['%s=%r' % (key, value)
11524 
      for key, value in self.__dict__.iteritems()]
11525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11526 
 
11527 
  def __eq__(self, other):
11528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11529 
 
11530 
  def __ne__(self, other):
11531 
    return not (self == other)
11532 
 
999 varun.gupt 11533 
class getOrdersByBillingDate_args:
11534 
  """
11535 
  Attributes:
11536 
   - status
11537 
   - start_billing_date
11538 
   - end_billing_date
11539 
   - warehouse_id
11540 
  """
11541 
 
11542 
  thrift_spec = (
11543 
    None, # 0
11544 
    (1, TType.I32, 'status', None, None, ), # 1
11545 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
11546 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
11547 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11548 
  )
11549 
 
11550 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
11551 
    self.status = status
11552 
    self.start_billing_date = start_billing_date
11553 
    self.end_billing_date = end_billing_date
11554 
    self.warehouse_id = warehouse_id
11555 
 
11556 
  def read(self, iprot):
11557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11559 
      return
11560 
    iprot.readStructBegin()
11561 
    while True:
11562 
      (fname, ftype, fid) = iprot.readFieldBegin()
11563 
      if ftype == TType.STOP:
11564 
        break
11565 
      if fid == 1:
11566 
        if ftype == TType.I32:
11567 
          self.status = iprot.readI32();
11568 
        else:
11569 
          iprot.skip(ftype)
11570 
      elif fid == 2:
11571 
        if ftype == TType.I64:
11572 
          self.start_billing_date = iprot.readI64();
11573 
        else:
11574 
          iprot.skip(ftype)
11575 
      elif fid == 3:
11576 
        if ftype == TType.I64:
11577 
          self.end_billing_date = iprot.readI64();
11578 
        else:
11579 
          iprot.skip(ftype)
11580 
      elif fid == 4:
11581 
        if ftype == TType.I64:
11582 
          self.warehouse_id = iprot.readI64();
11583 
        else:
11584 
          iprot.skip(ftype)
11585 
      else:
11586 
        iprot.skip(ftype)
11587 
      iprot.readFieldEnd()
11588 
    iprot.readStructEnd()
11589 
 
11590 
  def write(self, oprot):
11591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11593 
      return
11594 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 11595 
    if self.status is not None:
999 varun.gupt 11596 
      oprot.writeFieldBegin('status', TType.I32, 1)
11597 
      oprot.writeI32(self.status)
11598 
      oprot.writeFieldEnd()
3431 rajveer 11599 
    if self.start_billing_date is not None:
999 varun.gupt 11600 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
11601 
      oprot.writeI64(self.start_billing_date)
11602 
      oprot.writeFieldEnd()
3431 rajveer 11603 
    if self.end_billing_date is not None:
999 varun.gupt 11604 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
11605 
      oprot.writeI64(self.end_billing_date)
11606 
      oprot.writeFieldEnd()
3431 rajveer 11607 
    if self.warehouse_id is not None:
999 varun.gupt 11608 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11609 
      oprot.writeI64(self.warehouse_id)
11610 
      oprot.writeFieldEnd()
11611 
    oprot.writeFieldStop()
11612 
    oprot.writeStructEnd()
11613 
 
3431 rajveer 11614 
  def validate(self):
11615 
    return
11616 
 
11617 
 
999 varun.gupt 11618 
  def __repr__(self):
11619 
    L = ['%s=%r' % (key, value)
11620 
      for key, value in self.__dict__.iteritems()]
11621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11622 
 
11623 
  def __eq__(self, other):
11624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11625 
 
11626 
  def __ne__(self, other):
11627 
    return not (self == other)
11628 
 
11629 
class getOrdersByBillingDate_result:
11630 
  """
11631 
  Attributes:
11632 
   - success
11633 
   - ex
11634 
  """
11635 
 
11636 
  thrift_spec = (
11637 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11638 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11639 
  )
11640 
 
11641 
  def __init__(self, success=None, ex=None,):
11642 
    self.success = success
11643 
    self.ex = ex
11644 
 
11645 
  def read(self, iprot):
11646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11648 
      return
11649 
    iprot.readStructBegin()
11650 
    while True:
11651 
      (fname, ftype, fid) = iprot.readFieldBegin()
11652 
      if ftype == TType.STOP:
11653 
        break
11654 
      if fid == 0:
11655 
        if ftype == TType.LIST:
11656 
          self.success = []
6188 rajveer 11657 
          (_etype158, _size155) = iprot.readListBegin()
11658 
          for _i159 in xrange(_size155):
11659 
            _elem160 = Order()
11660 
            _elem160.read(iprot)
11661 
            self.success.append(_elem160)
999 varun.gupt 11662 
          iprot.readListEnd()
11663 
        else:
11664 
          iprot.skip(ftype)
11665 
      elif fid == 1:
11666 
        if ftype == TType.STRUCT:
11667 
          self.ex = TransactionServiceException()
11668 
          self.ex.read(iprot)
11669 
        else:
11670 
          iprot.skip(ftype)
11671 
      else:
11672 
        iprot.skip(ftype)
11673 
      iprot.readFieldEnd()
11674 
    iprot.readStructEnd()
11675 
 
11676 
  def write(self, oprot):
11677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11679 
      return
11680 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11681 
    if self.success is not None:
999 varun.gupt 11682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11683 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11684 
      for iter161 in self.success:
11685 
        iter161.write(oprot)
999 varun.gupt 11686 
      oprot.writeListEnd()
11687 
      oprot.writeFieldEnd()
3431 rajveer 11688 
    if self.ex is not None:
999 varun.gupt 11689 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11690 
      self.ex.write(oprot)
11691 
      oprot.writeFieldEnd()
11692 
    oprot.writeFieldStop()
11693 
    oprot.writeStructEnd()
11694 
 
3431 rajveer 11695 
  def validate(self):
11696 
    return
11697 
 
11698 
 
999 varun.gupt 11699 
  def __repr__(self):
11700 
    L = ['%s=%r' % (key, value)
11701 
      for key, value in self.__dict__.iteritems()]
11702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11703 
 
11704 
  def __eq__(self, other):
11705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11706 
 
11707 
  def __ne__(self, other):
11708 
    return not (self == other)
11709 
 
3427 chandransh 11710 
class getOrdersByShippingDate_args:
11711 
  """
11712 
  Attributes:
11713 
   - fromShippingDate
11714 
   - toShippingDate
11715 
   - providerId
11716 
   - warehouseId
3451 chandransh 11717 
   - cod
3427 chandransh 11718 
  """
11719 
 
11720 
  thrift_spec = (
11721 
    None, # 0
11722 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11723 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11724 
    (3, TType.I64, 'providerId', None, None, ), # 3
11725 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11726 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11727 
  )
11728 
 
3451 chandransh 11729 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11730 
    self.fromShippingDate = fromShippingDate
11731 
    self.toShippingDate = toShippingDate
11732 
    self.providerId = providerId
11733 
    self.warehouseId = warehouseId
3451 chandransh 11734 
    self.cod = cod
3427 chandransh 11735 
 
11736 
  def read(self, iprot):
11737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11739 
      return
11740 
    iprot.readStructBegin()
11741 
    while True:
11742 
      (fname, ftype, fid) = iprot.readFieldBegin()
11743 
      if ftype == TType.STOP:
11744 
        break
11745 
      if fid == 1:
11746 
        if ftype == TType.I64:
11747 
          self.fromShippingDate = iprot.readI64();
11748 
        else:
11749 
          iprot.skip(ftype)
11750 
      elif fid == 2:
11751 
        if ftype == TType.I64:
11752 
          self.toShippingDate = iprot.readI64();
11753 
        else:
11754 
          iprot.skip(ftype)
11755 
      elif fid == 3:
11756 
        if ftype == TType.I64:
11757 
          self.providerId = iprot.readI64();
11758 
        else:
11759 
          iprot.skip(ftype)
11760 
      elif fid == 4:
11761 
        if ftype == TType.I64:
11762 
          self.warehouseId = iprot.readI64();
11763 
        else:
11764 
          iprot.skip(ftype)
3451 chandransh 11765 
      elif fid == 5:
11766 
        if ftype == TType.BOOL:
11767 
          self.cod = iprot.readBool();
11768 
        else:
11769 
          iprot.skip(ftype)
3427 chandransh 11770 
      else:
11771 
        iprot.skip(ftype)
11772 
      iprot.readFieldEnd()
11773 
    iprot.readStructEnd()
11774 
 
11775 
  def write(self, oprot):
11776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11778 
      return
11779 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11780 
    if self.fromShippingDate is not None:
3427 chandransh 11781 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11782 
      oprot.writeI64(self.fromShippingDate)
11783 
      oprot.writeFieldEnd()
3431 rajveer 11784 
    if self.toShippingDate is not None:
3427 chandransh 11785 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11786 
      oprot.writeI64(self.toShippingDate)
11787 
      oprot.writeFieldEnd()
3431 rajveer 11788 
    if self.providerId is not None:
3427 chandransh 11789 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11790 
      oprot.writeI64(self.providerId)
11791 
      oprot.writeFieldEnd()
3431 rajveer 11792 
    if self.warehouseId is not None:
3427 chandransh 11793 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11794 
      oprot.writeI64(self.warehouseId)
11795 
      oprot.writeFieldEnd()
3451 chandransh 11796 
    if self.cod is not None:
11797 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11798 
      oprot.writeBool(self.cod)
11799 
      oprot.writeFieldEnd()
3427 chandransh 11800 
    oprot.writeFieldStop()
11801 
    oprot.writeStructEnd()
11802 
 
3431 rajveer 11803 
  def validate(self):
11804 
    return
11805 
 
11806 
 
3427 chandransh 11807 
  def __repr__(self):
11808 
    L = ['%s=%r' % (key, value)
11809 
      for key, value in self.__dict__.iteritems()]
11810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11811 
 
11812 
  def __eq__(self, other):
11813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11814 
 
11815 
  def __ne__(self, other):
11816 
    return not (self == other)
11817 
 
11818 
class getOrdersByShippingDate_result:
11819 
  """
11820 
  Attributes:
11821 
   - success
11822 
   - ex
11823 
  """
11824 
 
11825 
  thrift_spec = (
11826 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11828 
  )
11829 
 
11830 
  def __init__(self, success=None, ex=None,):
11831 
    self.success = success
11832 
    self.ex = ex
11833 
 
11834 
  def read(self, iprot):
11835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11837 
      return
11838 
    iprot.readStructBegin()
11839 
    while True:
11840 
      (fname, ftype, fid) = iprot.readFieldBegin()
11841 
      if ftype == TType.STOP:
11842 
        break
11843 
      if fid == 0:
11844 
        if ftype == TType.LIST:
11845 
          self.success = []
6188 rajveer 11846 
          (_etype165, _size162) = iprot.readListBegin()
11847 
          for _i166 in xrange(_size162):
11848 
            _elem167 = Order()
11849 
            _elem167.read(iprot)
11850 
            self.success.append(_elem167)
3427 chandransh 11851 
          iprot.readListEnd()
11852 
        else:
11853 
          iprot.skip(ftype)
11854 
      elif fid == 1:
11855 
        if ftype == TType.STRUCT:
11856 
          self.ex = TransactionServiceException()
11857 
          self.ex.read(iprot)
11858 
        else:
11859 
          iprot.skip(ftype)
11860 
      else:
11861 
        iprot.skip(ftype)
11862 
      iprot.readFieldEnd()
11863 
    iprot.readStructEnd()
11864 
 
11865 
  def write(self, oprot):
11866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11868 
      return
11869 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11870 
    if self.success is not None:
3427 chandransh 11871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11873 
      for iter168 in self.success:
11874 
        iter168.write(oprot)
3427 chandransh 11875 
      oprot.writeListEnd()
11876 
      oprot.writeFieldEnd()
3431 rajveer 11877 
    if self.ex is not None:
3427 chandransh 11878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11879 
      self.ex.write(oprot)
11880 
      oprot.writeFieldEnd()
11881 
    oprot.writeFieldStop()
11882 
    oprot.writeStructEnd()
11883 
 
3431 rajveer 11884 
  def validate(self):
11885 
    return
11886 
 
11887 
 
3427 chandransh 11888 
  def __repr__(self):
11889 
    L = ['%s=%r' % (key, value)
11890 
      for key, value in self.__dict__.iteritems()]
11891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11892 
 
11893 
  def __eq__(self, other):
11894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11895 
 
11896 
  def __ne__(self, other):
11897 
    return not (self == other)
11898 
 
1382 varun.gupt 11899 
class getReturnableOrdersForCustomer_args:
11900 
  """
11901 
  Attributes:
11902 
   - customer_id
11903 
   - limit
11904 
  """
11905 
 
11906 
  thrift_spec = (
11907 
    None, # 0
11908 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11909 
    (2, TType.I64, 'limit', None, None, ), # 2
11910 
  )
11911 
 
11912 
  def __init__(self, customer_id=None, limit=None,):
11913 
    self.customer_id = customer_id
11914 
    self.limit = limit
11915 
 
11916 
  def read(self, iprot):
11917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11919 
      return
11920 
    iprot.readStructBegin()
11921 
    while True:
11922 
      (fname, ftype, fid) = iprot.readFieldBegin()
11923 
      if ftype == TType.STOP:
11924 
        break
11925 
      if fid == 1:
11926 
        if ftype == TType.I64:
11927 
          self.customer_id = iprot.readI64();
11928 
        else:
11929 
          iprot.skip(ftype)
11930 
      elif fid == 2:
11931 
        if ftype == TType.I64:
11932 
          self.limit = iprot.readI64();
11933 
        else:
11934 
          iprot.skip(ftype)
11935 
      else:
11936 
        iprot.skip(ftype)
11937 
      iprot.readFieldEnd()
11938 
    iprot.readStructEnd()
11939 
 
11940 
  def write(self, oprot):
11941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11943 
      return
11944 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11945 
    if self.customer_id is not None:
1382 varun.gupt 11946 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11947 
      oprot.writeI64(self.customer_id)
11948 
      oprot.writeFieldEnd()
3431 rajveer 11949 
    if self.limit is not None:
1382 varun.gupt 11950 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11951 
      oprot.writeI64(self.limit)
11952 
      oprot.writeFieldEnd()
11953 
    oprot.writeFieldStop()
11954 
    oprot.writeStructEnd()
11955 
 
3431 rajveer 11956 
  def validate(self):
11957 
    return
11958 
 
11959 
 
1382 varun.gupt 11960 
  def __repr__(self):
11961 
    L = ['%s=%r' % (key, value)
11962 
      for key, value in self.__dict__.iteritems()]
11963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11964 
 
11965 
  def __eq__(self, other):
11966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11967 
 
11968 
  def __ne__(self, other):
11969 
    return not (self == other)
11970 
 
11971 
class getReturnableOrdersForCustomer_result:
11972 
  """
11973 
  Attributes:
11974 
   - success
11975 
   - ex
11976 
  """
11977 
 
11978 
  thrift_spec = (
11979 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11980 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11981 
  )
11982 
 
11983 
  def __init__(self, success=None, ex=None,):
11984 
    self.success = success
11985 
    self.ex = ex
11986 
 
11987 
  def read(self, iprot):
11988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11990 
      return
11991 
    iprot.readStructBegin()
11992 
    while True:
11993 
      (fname, ftype, fid) = iprot.readFieldBegin()
11994 
      if ftype == TType.STOP:
11995 
        break
11996 
      if fid == 0:
11997 
        if ftype == TType.LIST:
11998 
          self.success = []
6188 rajveer 11999 
          (_etype172, _size169) = iprot.readListBegin()
12000 
          for _i173 in xrange(_size169):
12001 
            _elem174 = iprot.readI64();
12002 
            self.success.append(_elem174)
1382 varun.gupt 12003 
          iprot.readListEnd()
12004 
        else:
12005 
          iprot.skip(ftype)
12006 
      elif fid == 1:
12007 
        if ftype == TType.STRUCT:
12008 
          self.ex = TransactionServiceException()
12009 
          self.ex.read(iprot)
12010 
        else:
12011 
          iprot.skip(ftype)
12012 
      else:
12013 
        iprot.skip(ftype)
12014 
      iprot.readFieldEnd()
12015 
    iprot.readStructEnd()
12016 
 
12017 
  def write(self, oprot):
12018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12020 
      return
12021 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 12022 
    if self.success is not None:
1382 varun.gupt 12023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12024 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 12025 
      for iter175 in self.success:
12026 
        oprot.writeI64(iter175)
1382 varun.gupt 12027 
      oprot.writeListEnd()
12028 
      oprot.writeFieldEnd()
3431 rajveer 12029 
    if self.ex is not None:
1382 varun.gupt 12030 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12031 
      self.ex.write(oprot)
12032 
      oprot.writeFieldEnd()
12033 
    oprot.writeFieldStop()
12034 
    oprot.writeStructEnd()
12035 
 
3431 rajveer 12036 
  def validate(self):
12037 
    return
12038 
 
12039 
 
1382 varun.gupt 12040 
  def __repr__(self):
12041 
    L = ['%s=%r' % (key, value)
12042 
      for key, value in self.__dict__.iteritems()]
12043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12044 
 
12045 
  def __eq__(self, other):
12046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12047 
 
12048 
  def __ne__(self, other):
12049 
    return not (self == other)
12050 
 
12051 
class getCancellableOrdersForCustomer_args:
12052 
  """
12053 
  Attributes:
12054 
   - customer_id
12055 
   - limit
12056 
  """
12057 
 
12058 
  thrift_spec = (
12059 
    None, # 0
12060 
    (1, TType.I64, 'customer_id', None, None, ), # 1
12061 
    (2, TType.I64, 'limit', None, None, ), # 2
12062 
  )
12063 
 
12064 
  def __init__(self, customer_id=None, limit=None,):
12065 
    self.customer_id = customer_id
12066 
    self.limit = limit
12067 
 
12068 
  def read(self, iprot):
12069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12071 
      return
12072 
    iprot.readStructBegin()
12073 
    while True:
12074 
      (fname, ftype, fid) = iprot.readFieldBegin()
12075 
      if ftype == TType.STOP:
12076 
        break
12077 
      if fid == 1:
12078 
        if ftype == TType.I64:
12079 
          self.customer_id = iprot.readI64();
12080 
        else:
12081 
          iprot.skip(ftype)
12082 
      elif fid == 2:
12083 
        if ftype == TType.I64:
12084 
          self.limit = iprot.readI64();
12085 
        else:
12086 
          iprot.skip(ftype)
12087 
      else:
12088 
        iprot.skip(ftype)
12089 
      iprot.readFieldEnd()
12090 
    iprot.readStructEnd()
12091 
 
12092 
  def write(self, oprot):
12093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12095 
      return
12096 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 12097 
    if self.customer_id is not None:
1382 varun.gupt 12098 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
12099 
      oprot.writeI64(self.customer_id)
12100 
      oprot.writeFieldEnd()
3431 rajveer 12101 
    if self.limit is not None:
1382 varun.gupt 12102 
      oprot.writeFieldBegin('limit', TType.I64, 2)
12103 
      oprot.writeI64(self.limit)
12104 
      oprot.writeFieldEnd()
12105 
    oprot.writeFieldStop()
12106 
    oprot.writeStructEnd()
12107 
 
3431 rajveer 12108 
  def validate(self):
12109 
    return
12110 
 
12111 
 
1382 varun.gupt 12112 
  def __repr__(self):
12113 
    L = ['%s=%r' % (key, value)
12114 
      for key, value in self.__dict__.iteritems()]
12115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12116 
 
12117 
  def __eq__(self, other):
12118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12119 
 
12120 
  def __ne__(self, other):
12121 
    return not (self == other)
12122 
 
12123 
class getCancellableOrdersForCustomer_result:
12124 
  """
12125 
  Attributes:
12126 
   - success
12127 
   - ex
12128 
  """
12129 
 
12130 
  thrift_spec = (
12131 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12132 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12133 
  )
12134 
 
12135 
  def __init__(self, success=None, ex=None,):
12136 
    self.success = success
12137 
    self.ex = ex
12138 
 
12139 
  def read(self, iprot):
12140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12142 
      return
12143 
    iprot.readStructBegin()
12144 
    while True:
12145 
      (fname, ftype, fid) = iprot.readFieldBegin()
12146 
      if ftype == TType.STOP:
12147 
        break
12148 
      if fid == 0:
12149 
        if ftype == TType.LIST:
12150 
          self.success = []
6188 rajveer 12151 
          (_etype179, _size176) = iprot.readListBegin()
12152 
          for _i180 in xrange(_size176):
12153 
            _elem181 = iprot.readI64();
12154 
            self.success.append(_elem181)
1382 varun.gupt 12155 
          iprot.readListEnd()
12156 
        else:
12157 
          iprot.skip(ftype)
12158 
      elif fid == 1:
12159 
        if ftype == TType.STRUCT:
12160 
          self.ex = TransactionServiceException()
12161 
          self.ex.read(iprot)
12162 
        else:
12163 
          iprot.skip(ftype)
12164 
      else:
12165 
        iprot.skip(ftype)
12166 
      iprot.readFieldEnd()
12167 
    iprot.readStructEnd()
12168 
 
12169 
  def write(self, oprot):
12170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12172 
      return
12173 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 12174 
    if self.success is not None:
1382 varun.gupt 12175 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12176 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 12177 
      for iter182 in self.success:
12178 
        oprot.writeI64(iter182)
1382 varun.gupt 12179 
      oprot.writeListEnd()
12180 
      oprot.writeFieldEnd()
3431 rajveer 12181 
    if self.ex is not None:
1382 varun.gupt 12182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12183 
      self.ex.write(oprot)
12184 
      oprot.writeFieldEnd()
12185 
    oprot.writeFieldStop()
12186 
    oprot.writeStructEnd()
12187 
 
3431 rajveer 12188 
  def validate(self):
12189 
    return
12190 
 
12191 
 
1382 varun.gupt 12192 
  def __repr__(self):
12193 
    L = ['%s=%r' % (key, value)
12194 
      for key, value in self.__dict__.iteritems()]
12195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12196 
 
12197 
  def __eq__(self, other):
12198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12199 
 
12200 
  def __ne__(self, other):
12201 
    return not (self == other)
12202 
 
483 rajveer 12203 
class changeOrderStatus_args:
94 ashish 12204 
  """
12205 
  Attributes:
483 rajveer 12206 
   - orderId
12207 
   - status
12208 
   - description
94 ashish 12209 
  """
12210 
 
12211 
  thrift_spec = (
12212 
    None, # 0
483 rajveer 12213 
    (1, TType.I64, 'orderId', None, None, ), # 1
12214 
    (2, TType.I32, 'status', None, None, ), # 2
12215 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12216 
  )
12217 
 
483 rajveer 12218 
  def __init__(self, orderId=None, status=None, description=None,):
12219 
    self.orderId = orderId
12220 
    self.status = status
12221 
    self.description = description
94 ashish 12222 
 
12223 
  def read(self, iprot):
12224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12226 
      return
12227 
    iprot.readStructBegin()
12228 
    while True:
12229 
      (fname, ftype, fid) = iprot.readFieldBegin()
12230 
      if ftype == TType.STOP:
12231 
        break
12232 
      if fid == 1:
12233 
        if ftype == TType.I64:
483 rajveer 12234 
          self.orderId = iprot.readI64();
94 ashish 12235 
        else:
12236 
          iprot.skip(ftype)
12237 
      elif fid == 2:
483 rajveer 12238 
        if ftype == TType.I32:
12239 
          self.status = iprot.readI32();
94 ashish 12240 
        else:
12241 
          iprot.skip(ftype)
483 rajveer 12242 
      elif fid == 3:
12243 
        if ftype == TType.STRING:
12244 
          self.description = iprot.readString();
12245 
        else:
12246 
          iprot.skip(ftype)
94 ashish 12247 
      else:
12248 
        iprot.skip(ftype)
12249 
      iprot.readFieldEnd()
12250 
    iprot.readStructEnd()
12251 
 
12252 
  def write(self, oprot):
12253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12255 
      return
483 rajveer 12256 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 12257 
    if self.orderId is not None:
483 rajveer 12258 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12259 
      oprot.writeI64(self.orderId)
94 ashish 12260 
      oprot.writeFieldEnd()
3431 rajveer 12261 
    if self.status is not None:
483 rajveer 12262 
      oprot.writeFieldBegin('status', TType.I32, 2)
12263 
      oprot.writeI32(self.status)
94 ashish 12264 
      oprot.writeFieldEnd()
3431 rajveer 12265 
    if self.description is not None:
483 rajveer 12266 
      oprot.writeFieldBegin('description', TType.STRING, 3)
12267 
      oprot.writeString(self.description)
12268 
      oprot.writeFieldEnd()
94 ashish 12269 
    oprot.writeFieldStop()
12270 
    oprot.writeStructEnd()
12271 
 
3431 rajveer 12272 
  def validate(self):
12273 
    return
12274 
 
12275 
 
94 ashish 12276 
  def __repr__(self):
12277 
    L = ['%s=%r' % (key, value)
12278 
      for key, value in self.__dict__.iteritems()]
12279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12280 
 
12281 
  def __eq__(self, other):
12282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12283 
 
12284 
  def __ne__(self, other):
12285 
    return not (self == other)
12286 
 
483 rajveer 12287 
class changeOrderStatus_result:
94 ashish 12288 
  """
12289 
  Attributes:
12290 
   - success
12291 
   - ex
12292 
  """
12293 
 
12294 
  thrift_spec = (
12295 
    (0, TType.BOOL, 'success', None, None, ), # 0
12296 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12297 
  )
12298 
 
12299 
  def __init__(self, success=None, ex=None,):
12300 
    self.success = success
12301 
    self.ex = ex
12302 
 
12303 
  def read(self, iprot):
12304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12306 
      return
12307 
    iprot.readStructBegin()
12308 
    while True:
12309 
      (fname, ftype, fid) = iprot.readFieldBegin()
12310 
      if ftype == TType.STOP:
12311 
        break
12312 
      if fid == 0:
12313 
        if ftype == TType.BOOL:
12314 
          self.success = iprot.readBool();
12315 
        else:
12316 
          iprot.skip(ftype)
12317 
      elif fid == 1:
12318 
        if ftype == TType.STRUCT:
12319 
          self.ex = TransactionServiceException()
12320 
          self.ex.read(iprot)
12321 
        else:
12322 
          iprot.skip(ftype)
12323 
      else:
12324 
        iprot.skip(ftype)
12325 
      iprot.readFieldEnd()
12326 
    iprot.readStructEnd()
12327 
 
12328 
  def write(self, oprot):
12329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12331 
      return
483 rajveer 12332 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 12333 
    if self.success is not None:
94 ashish 12334 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12335 
      oprot.writeBool(self.success)
12336 
      oprot.writeFieldEnd()
3431 rajveer 12337 
    if self.ex is not None:
94 ashish 12338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12339 
      self.ex.write(oprot)
12340 
      oprot.writeFieldEnd()
12341 
    oprot.writeFieldStop()
12342 
    oprot.writeStructEnd()
12343 
 
3431 rajveer 12344 
  def validate(self):
12345 
    return
12346 
 
12347 
 
94 ashish 12348 
  def __repr__(self):
12349 
    L = ['%s=%r' % (key, value)
12350 
      for key, value in self.__dict__.iteritems()]
12351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12352 
 
12353 
  def __eq__(self, other):
12354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12355 
 
12356 
  def __ne__(self, other):
12357 
    return not (self == other)
12358 
 
3064 chandransh 12359 
class getOrdersForTransaction_args:
494 rajveer 12360 
  """
12361 
  Attributes:
3064 chandransh 12362 
   - transactionId
12363 
   - customerId
494 rajveer 12364 
  """
12365 
 
12366 
  thrift_spec = (
12367 
    None, # 0
3064 chandransh 12368 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12369 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 12370 
  )
12371 
 
3064 chandransh 12372 
  def __init__(self, transactionId=None, customerId=None,):
12373 
    self.transactionId = transactionId
12374 
    self.customerId = customerId
494 rajveer 12375 
 
12376 
  def read(self, iprot):
12377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12379 
      return
12380 
    iprot.readStructBegin()
12381 
    while True:
12382 
      (fname, ftype, fid) = iprot.readFieldBegin()
12383 
      if ftype == TType.STOP:
12384 
        break
12385 
      if fid == 1:
12386 
        if ftype == TType.I64:
3064 chandransh 12387 
          self.transactionId = iprot.readI64();
494 rajveer 12388 
        else:
12389 
          iprot.skip(ftype)
12390 
      elif fid == 2:
3064 chandransh 12391 
        if ftype == TType.I64:
12392 
          self.customerId = iprot.readI64();
494 rajveer 12393 
        else:
12394 
          iprot.skip(ftype)
12395 
      else:
12396 
        iprot.skip(ftype)
12397 
      iprot.readFieldEnd()
12398 
    iprot.readStructEnd()
12399 
 
12400 
  def write(self, oprot):
12401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12403 
      return
3064 chandransh 12404 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 12405 
    if self.transactionId is not None:
3064 chandransh 12406 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12407 
      oprot.writeI64(self.transactionId)
494 rajveer 12408 
      oprot.writeFieldEnd()
3431 rajveer 12409 
    if self.customerId is not None:
3064 chandransh 12410 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
12411 
      oprot.writeI64(self.customerId)
494 rajveer 12412 
      oprot.writeFieldEnd()
12413 
    oprot.writeFieldStop()
12414 
    oprot.writeStructEnd()
12415 
 
3431 rajveer 12416 
  def validate(self):
12417 
    return
12418 
 
12419 
 
494 rajveer 12420 
  def __repr__(self):
12421 
    L = ['%s=%r' % (key, value)
12422 
      for key, value in self.__dict__.iteritems()]
12423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12424 
 
12425 
  def __eq__(self, other):
12426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12427 
 
12428 
  def __ne__(self, other):
12429 
    return not (self == other)
12430 
 
3064 chandransh 12431 
class getOrdersForTransaction_result:
494 rajveer 12432 
  """
12433 
  Attributes:
12434 
   - success
12435 
   - ex
12436 
  """
12437 
 
12438 
  thrift_spec = (
3064 chandransh 12439 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 12440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12441 
  )
12442 
 
12443 
  def __init__(self, success=None, ex=None,):
12444 
    self.success = success
12445 
    self.ex = ex
12446 
 
12447 
  def read(self, iprot):
12448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12450 
      return
12451 
    iprot.readStructBegin()
12452 
    while True:
12453 
      (fname, ftype, fid) = iprot.readFieldBegin()
12454 
      if ftype == TType.STOP:
12455 
        break
12456 
      if fid == 0:
3064 chandransh 12457 
        if ftype == TType.LIST:
12458 
          self.success = []
6188 rajveer 12459 
          (_etype186, _size183) = iprot.readListBegin()
12460 
          for _i187 in xrange(_size183):
12461 
            _elem188 = Order()
12462 
            _elem188.read(iprot)
12463 
            self.success.append(_elem188)
3064 chandransh 12464 
          iprot.readListEnd()
494 rajveer 12465 
        else:
12466 
          iprot.skip(ftype)
12467 
      elif fid == 1:
12468 
        if ftype == TType.STRUCT:
12469 
          self.ex = TransactionServiceException()
12470 
          self.ex.read(iprot)
12471 
        else:
12472 
          iprot.skip(ftype)
12473 
      else:
12474 
        iprot.skip(ftype)
12475 
      iprot.readFieldEnd()
12476 
    iprot.readStructEnd()
12477 
 
12478 
  def write(self, oprot):
12479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12481 
      return
3064 chandransh 12482 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 12483 
    if self.success is not None:
3064 chandransh 12484 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12485 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12486 
      for iter189 in self.success:
12487 
        iter189.write(oprot)
3064 chandransh 12488 
      oprot.writeListEnd()
494 rajveer 12489 
      oprot.writeFieldEnd()
3431 rajveer 12490 
    if self.ex is not None:
494 rajveer 12491 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12492 
      self.ex.write(oprot)
12493 
      oprot.writeFieldEnd()
12494 
    oprot.writeFieldStop()
12495 
    oprot.writeStructEnd()
12496 
 
3431 rajveer 12497 
  def validate(self):
12498 
    return
12499 
 
12500 
 
494 rajveer 12501 
  def __repr__(self):
12502 
    L = ['%s=%r' % (key, value)
12503 
      for key, value in self.__dict__.iteritems()]
12504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12505 
 
12506 
  def __eq__(self, other):
12507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12508 
 
12509 
  def __ne__(self, other):
12510 
    return not (self == other)
12511 
 
3064 chandransh 12512 
class getOrdersForCustomer_args:
1149 chandransh 12513 
  """
12514 
  Attributes:
3064 chandransh 12515 
   - customerId
12516 
   - from_date
12517 
   - to_date
12518 
   - statuses
1149 chandransh 12519 
  """
12520 
 
12521 
  thrift_spec = (
12522 
    None, # 0
3064 chandransh 12523 
    (1, TType.I64, 'customerId', None, None, ), # 1
12524 
    (2, TType.I64, 'from_date', None, None, ), # 2
12525 
    (3, TType.I64, 'to_date', None, None, ), # 3
12526 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 12527 
  )
12528 
 
3064 chandransh 12529 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
12530 
    self.customerId = customerId
12531 
    self.from_date = from_date
12532 
    self.to_date = to_date
12533 
    self.statuses = statuses
1149 chandransh 12534 
 
12535 
  def read(self, iprot):
12536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12538 
      return
12539 
    iprot.readStructBegin()
12540 
    while True:
12541 
      (fname, ftype, fid) = iprot.readFieldBegin()
12542 
      if ftype == TType.STOP:
12543 
        break
12544 
      if fid == 1:
12545 
        if ftype == TType.I64:
3064 chandransh 12546 
          self.customerId = iprot.readI64();
1149 chandransh 12547 
        else:
12548 
          iprot.skip(ftype)
12549 
      elif fid == 2:
12550 
        if ftype == TType.I64:
3064 chandransh 12551 
          self.from_date = iprot.readI64();
1149 chandransh 12552 
        else:
12553 
          iprot.skip(ftype)
2783 chandransh 12554 
      elif fid == 3:
12555 
        if ftype == TType.I64:
3064 chandransh 12556 
          self.to_date = iprot.readI64();
2783 chandransh 12557 
        else:
12558 
          iprot.skip(ftype)
12559 
      elif fid == 4:
3064 chandransh 12560 
        if ftype == TType.LIST:
12561 
          self.statuses = []
6188 rajveer 12562 
          (_etype193, _size190) = iprot.readListBegin()
12563 
          for _i194 in xrange(_size190):
12564 
            _elem195 = iprot.readI32();
12565 
            self.statuses.append(_elem195)
3064 chandransh 12566 
          iprot.readListEnd()
2783 chandransh 12567 
        else:
12568 
          iprot.skip(ftype)
1149 chandransh 12569 
      else:
12570 
        iprot.skip(ftype)
12571 
      iprot.readFieldEnd()
12572 
    iprot.readStructEnd()
12573 
 
12574 
  def write(self, oprot):
12575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12577 
      return
3064 chandransh 12578 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 12579 
    if self.customerId is not None:
3064 chandransh 12580 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
12581 
      oprot.writeI64(self.customerId)
1149 chandransh 12582 
      oprot.writeFieldEnd()
3431 rajveer 12583 
    if self.from_date is not None:
3064 chandransh 12584 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
12585 
      oprot.writeI64(self.from_date)
1149 chandransh 12586 
      oprot.writeFieldEnd()
3431 rajveer 12587 
    if self.to_date is not None:
3064 chandransh 12588 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
12589 
      oprot.writeI64(self.to_date)
2783 chandransh 12590 
      oprot.writeFieldEnd()
3431 rajveer 12591 
    if self.statuses is not None:
3064 chandransh 12592 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
12593 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 12594 
      for iter196 in self.statuses:
12595 
        oprot.writeI32(iter196)
3064 chandransh 12596 
      oprot.writeListEnd()
2783 chandransh 12597 
      oprot.writeFieldEnd()
1149 chandransh 12598 
    oprot.writeFieldStop()
12599 
    oprot.writeStructEnd()
12600 
 
3431 rajveer 12601 
  def validate(self):
12602 
    return
12603 
 
12604 
 
1149 chandransh 12605 
  def __repr__(self):
12606 
    L = ['%s=%r' % (key, value)
12607 
      for key, value in self.__dict__.iteritems()]
12608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12609 
 
12610 
  def __eq__(self, other):
12611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12612 
 
12613 
  def __ne__(self, other):
12614 
    return not (self == other)
12615 
 
3064 chandransh 12616 
class getOrdersForCustomer_result:
1149 chandransh 12617 
  """
12618 
  Attributes:
12619 
   - success
12620 
   - ex
12621 
  """
12622 
 
12623 
  thrift_spec = (
3064 chandransh 12624 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 12625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12626 
  )
12627 
 
12628 
  def __init__(self, success=None, ex=None,):
12629 
    self.success = success
12630 
    self.ex = ex
12631 
 
12632 
  def read(self, iprot):
12633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12635 
      return
12636 
    iprot.readStructBegin()
12637 
    while True:
12638 
      (fname, ftype, fid) = iprot.readFieldBegin()
12639 
      if ftype == TType.STOP:
12640 
        break
12641 
      if fid == 0:
3064 chandransh 12642 
        if ftype == TType.LIST:
12643 
          self.success = []
6188 rajveer 12644 
          (_etype200, _size197) = iprot.readListBegin()
12645 
          for _i201 in xrange(_size197):
12646 
            _elem202 = Order()
12647 
            _elem202.read(iprot)
12648 
            self.success.append(_elem202)
3064 chandransh 12649 
          iprot.readListEnd()
1149 chandransh 12650 
        else:
12651 
          iprot.skip(ftype)
12652 
      elif fid == 1:
12653 
        if ftype == TType.STRUCT:
12654 
          self.ex = TransactionServiceException()
12655 
          self.ex.read(iprot)
12656 
        else:
12657 
          iprot.skip(ftype)
12658 
      else:
12659 
        iprot.skip(ftype)
12660 
      iprot.readFieldEnd()
12661 
    iprot.readStructEnd()
12662 
 
12663 
  def write(self, oprot):
12664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12666 
      return
3064 chandransh 12667 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12668 
    if self.success is not None:
3064 chandransh 12669 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12670 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12671 
      for iter203 in self.success:
12672 
        iter203.write(oprot)
3064 chandransh 12673 
      oprot.writeListEnd()
1149 chandransh 12674 
      oprot.writeFieldEnd()
3431 rajveer 12675 
    if self.ex is not None:
1149 chandransh 12676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12677 
      self.ex.write(oprot)
12678 
      oprot.writeFieldEnd()
12679 
    oprot.writeFieldStop()
12680 
    oprot.writeStructEnd()
12681 
 
3431 rajveer 12682 
  def validate(self):
12683 
    return
12684 
 
12685 
 
1149 chandransh 12686 
  def __repr__(self):
12687 
    L = ['%s=%r' % (key, value)
12688 
      for key, value in self.__dict__.iteritems()]
12689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12690 
 
12691 
  def __eq__(self, other):
12692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12693 
 
12694 
  def __ne__(self, other):
12695 
    return not (self == other)
12696 
 
3064 chandransh 12697 
class createOrder_args:
921 rajveer 12698 
  """
12699 
  Attributes:
3064 chandransh 12700 
   - order
921 rajveer 12701 
  """
12702 
 
12703 
  thrift_spec = (
12704 
    None, # 0
3064 chandransh 12705 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12706 
  )
12707 
 
3064 chandransh 12708 
  def __init__(self, order=None,):
12709 
    self.order = order
921 rajveer 12710 
 
12711 
  def read(self, iprot):
12712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12714 
      return
12715 
    iprot.readStructBegin()
12716 
    while True:
12717 
      (fname, ftype, fid) = iprot.readFieldBegin()
12718 
      if ftype == TType.STOP:
12719 
        break
12720 
      if fid == 1:
3064 chandransh 12721 
        if ftype == TType.STRUCT:
12722 
          self.order = Order()
12723 
          self.order.read(iprot)
921 rajveer 12724 
        else:
12725 
          iprot.skip(ftype)
12726 
      else:
12727 
        iprot.skip(ftype)
12728 
      iprot.readFieldEnd()
12729 
    iprot.readStructEnd()
12730 
 
12731 
  def write(self, oprot):
12732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12734 
      return
3064 chandransh 12735 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12736 
    if self.order is not None:
3064 chandransh 12737 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12738 
      self.order.write(oprot)
921 rajveer 12739 
      oprot.writeFieldEnd()
12740 
    oprot.writeFieldStop()
12741 
    oprot.writeStructEnd()
12742 
 
3431 rajveer 12743 
  def validate(self):
12744 
    return
12745 
 
12746 
 
921 rajveer 12747 
  def __repr__(self):
12748 
    L = ['%s=%r' % (key, value)
12749 
      for key, value in self.__dict__.iteritems()]
12750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12751 
 
12752 
  def __eq__(self, other):
12753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12754 
 
12755 
  def __ne__(self, other):
12756 
    return not (self == other)
12757 
 
3064 chandransh 12758 
class createOrder_result:
921 rajveer 12759 
  """
12760 
  Attributes:
12761 
   - success
12762 
   - ex
12763 
  """
12764 
 
12765 
  thrift_spec = (
3064 chandransh 12766 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12767 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12768 
  )
12769 
 
12770 
  def __init__(self, success=None, ex=None,):
12771 
    self.success = success
12772 
    self.ex = ex
12773 
 
12774 
  def read(self, iprot):
12775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12777 
      return
12778 
    iprot.readStructBegin()
12779 
    while True:
12780 
      (fname, ftype, fid) = iprot.readFieldBegin()
12781 
      if ftype == TType.STOP:
12782 
        break
12783 
      if fid == 0:
3064 chandransh 12784 
        if ftype == TType.I64:
12785 
          self.success = iprot.readI64();
921 rajveer 12786 
        else:
12787 
          iprot.skip(ftype)
12788 
      elif fid == 1:
12789 
        if ftype == TType.STRUCT:
12790 
          self.ex = TransactionServiceException()
12791 
          self.ex.read(iprot)
12792 
        else:
12793 
          iprot.skip(ftype)
12794 
      else:
12795 
        iprot.skip(ftype)
12796 
      iprot.readFieldEnd()
12797 
    iprot.readStructEnd()
12798 
 
12799 
  def write(self, oprot):
12800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12802 
      return
3064 chandransh 12803 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12804 
    if self.success is not None:
3064 chandransh 12805 
      oprot.writeFieldBegin('success', TType.I64, 0)
12806 
      oprot.writeI64(self.success)
921 rajveer 12807 
      oprot.writeFieldEnd()
3431 rajveer 12808 
    if self.ex is not None:
921 rajveer 12809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12810 
      self.ex.write(oprot)
12811 
      oprot.writeFieldEnd()
12812 
    oprot.writeFieldStop()
12813 
    oprot.writeStructEnd()
12814 
 
3431 rajveer 12815 
  def validate(self):
12816 
    return
12817 
 
12818 
 
921 rajveer 12819 
  def __repr__(self):
12820 
    L = ['%s=%r' % (key, value)
12821 
      for key, value in self.__dict__.iteritems()]
12822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12823 
 
12824 
  def __eq__(self, other):
12825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12826 
 
12827 
  def __ne__(self, other):
12828 
    return not (self == other)
12829 
 
3064 chandransh 12830 
class getOrder_args:
921 rajveer 12831 
  """
12832 
  Attributes:
3064 chandransh 12833 
   - id
921 rajveer 12834 
  """
12835 
 
12836 
  thrift_spec = (
12837 
    None, # 0
3064 chandransh 12838 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12839 
  )
12840 
 
3064 chandransh 12841 
  def __init__(self, id=None,):
12842 
    self.id = id
921 rajveer 12843 
 
12844 
  def read(self, iprot):
12845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12847 
      return
12848 
    iprot.readStructBegin()
12849 
    while True:
12850 
      (fname, ftype, fid) = iprot.readFieldBegin()
12851 
      if ftype == TType.STOP:
12852 
        break
12853 
      if fid == 1:
12854 
        if ftype == TType.I64:
3064 chandransh 12855 
          self.id = iprot.readI64();
921 rajveer 12856 
        else:
12857 
          iprot.skip(ftype)
12858 
      else:
12859 
        iprot.skip(ftype)
12860 
      iprot.readFieldEnd()
12861 
    iprot.readStructEnd()
12862 
 
12863 
  def write(self, oprot):
12864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12866 
      return
3064 chandransh 12867 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12868 
    if self.id is not None:
3064 chandransh 12869 
      oprot.writeFieldBegin('id', TType.I64, 1)
12870 
      oprot.writeI64(self.id)
921 rajveer 12871 
      oprot.writeFieldEnd()
12872 
    oprot.writeFieldStop()
12873 
    oprot.writeStructEnd()
12874 
 
3431 rajveer 12875 
  def validate(self):
12876 
    return
12877 
 
12878 
 
921 rajveer 12879 
  def __repr__(self):
12880 
    L = ['%s=%r' % (key, value)
12881 
      for key, value in self.__dict__.iteritems()]
12882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12883 
 
12884 
  def __eq__(self, other):
12885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12886 
 
12887 
  def __ne__(self, other):
12888 
    return not (self == other)
12889 
 
3064 chandransh 12890 
class getOrder_result:
921 rajveer 12891 
  """
12892 
  Attributes:
12893 
   - success
12894 
   - ex
12895 
  """
12896 
 
12897 
  thrift_spec = (
3064 chandransh 12898 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12900 
  )
12901 
 
12902 
  def __init__(self, success=None, ex=None,):
12903 
    self.success = success
12904 
    self.ex = ex
12905 
 
12906 
  def read(self, iprot):
12907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12909 
      return
12910 
    iprot.readStructBegin()
12911 
    while True:
12912 
      (fname, ftype, fid) = iprot.readFieldBegin()
12913 
      if ftype == TType.STOP:
12914 
        break
12915 
      if fid == 0:
3064 chandransh 12916 
        if ftype == TType.STRUCT:
12917 
          self.success = Order()
12918 
          self.success.read(iprot)
921 rajveer 12919 
        else:
12920 
          iprot.skip(ftype)
12921 
      elif fid == 1:
12922 
        if ftype == TType.STRUCT:
12923 
          self.ex = TransactionServiceException()
12924 
          self.ex.read(iprot)
12925 
        else:
12926 
          iprot.skip(ftype)
12927 
      else:
12928 
        iprot.skip(ftype)
12929 
      iprot.readFieldEnd()
12930 
    iprot.readStructEnd()
12931 
 
12932 
  def write(self, oprot):
12933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12935 
      return
3064 chandransh 12936 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12937 
    if self.success is not None:
3064 chandransh 12938 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12939 
      self.success.write(oprot)
921 rajveer 12940 
      oprot.writeFieldEnd()
3431 rajveer 12941 
    if self.ex is not None:
921 rajveer 12942 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12943 
      self.ex.write(oprot)
12944 
      oprot.writeFieldEnd()
12945 
    oprot.writeFieldStop()
12946 
    oprot.writeStructEnd()
12947 
 
3431 rajveer 12948 
  def validate(self):
12949 
    return
12950 
 
12951 
 
921 rajveer 12952 
  def __repr__(self):
12953 
    L = ['%s=%r' % (key, value)
12954 
      for key, value in self.__dict__.iteritems()]
12955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12956 
 
12957 
  def __eq__(self, other):
12958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12959 
 
12960 
  def __ne__(self, other):
12961 
    return not (self == other)
12962 
 
3064 chandransh 12963 
class getLineItemsForOrder_args:
94 ashish 12964 
  """
12965 
  Attributes:
3064 chandransh 12966 
   - orderId
94 ashish 12967 
  """
12968 
 
12969 
  thrift_spec = (
12970 
    None, # 0
3064 chandransh 12971 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12972 
  )
12973 
 
3064 chandransh 12974 
  def __init__(self, orderId=None,):
12975 
    self.orderId = orderId
94 ashish 12976 
 
12977 
  def read(self, iprot):
12978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12980 
      return
12981 
    iprot.readStructBegin()
12982 
    while True:
12983 
      (fname, ftype, fid) = iprot.readFieldBegin()
12984 
      if ftype == TType.STOP:
12985 
        break
12986 
      if fid == 1:
12987 
        if ftype == TType.I64:
3064 chandransh 12988 
          self.orderId = iprot.readI64();
94 ashish 12989 
        else:
12990 
          iprot.skip(ftype)
12991 
      else:
12992 
        iprot.skip(ftype)
12993 
      iprot.readFieldEnd()
12994 
    iprot.readStructEnd()
12995 
 
12996 
  def write(self, oprot):
12997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12999 
      return
3064 chandransh 13000 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 13001 
    if self.orderId is not None:
3064 chandransh 13002 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13003 
      oprot.writeI64(self.orderId)
94 ashish 13004 
      oprot.writeFieldEnd()
13005 
    oprot.writeFieldStop()
13006 
    oprot.writeStructEnd()
13007 
 
3431 rajveer 13008 
  def validate(self):
13009 
    return
13010 
 
13011 
 
94 ashish 13012 
  def __repr__(self):
13013 
    L = ['%s=%r' % (key, value)
13014 
      for key, value in self.__dict__.iteritems()]
13015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13016 
 
13017 
  def __eq__(self, other):
13018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13019 
 
13020 
  def __ne__(self, other):
13021 
    return not (self == other)
13022 
 
3064 chandransh 13023 
class getLineItemsForOrder_result:
94 ashish 13024 
  """
13025 
  Attributes:
13026 
   - success
13027 
   - ex
13028 
  """
13029 
 
13030 
  thrift_spec = (
3064 chandransh 13031 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 13032 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13033 
  )
13034 
 
13035 
  def __init__(self, success=None, ex=None,):
13036 
    self.success = success
13037 
    self.ex = ex
13038 
 
13039 
  def read(self, iprot):
13040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13042 
      return
13043 
    iprot.readStructBegin()
13044 
    while True:
13045 
      (fname, ftype, fid) = iprot.readFieldBegin()
13046 
      if ftype == TType.STOP:
13047 
        break
13048 
      if fid == 0:
483 rajveer 13049 
        if ftype == TType.LIST:
13050 
          self.success = []
6188 rajveer 13051 
          (_etype207, _size204) = iprot.readListBegin()
13052 
          for _i208 in xrange(_size204):
13053 
            _elem209 = LineItem()
13054 
            _elem209.read(iprot)
13055 
            self.success.append(_elem209)
483 rajveer 13056 
          iprot.readListEnd()
94 ashish 13057 
        else:
13058 
          iprot.skip(ftype)
13059 
      elif fid == 1:
13060 
        if ftype == TType.STRUCT:
13061 
          self.ex = TransactionServiceException()
13062 
          self.ex.read(iprot)
13063 
        else:
13064 
          iprot.skip(ftype)
13065 
      else:
13066 
        iprot.skip(ftype)
13067 
      iprot.readFieldEnd()
13068 
    iprot.readStructEnd()
13069 
 
13070 
  def write(self, oprot):
13071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13073 
      return
3064 chandransh 13074 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 13075 
    if self.success is not None:
483 rajveer 13076 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13077 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13078 
      for iter210 in self.success:
13079 
        iter210.write(oprot)
483 rajveer 13080 
      oprot.writeListEnd()
94 ashish 13081 
      oprot.writeFieldEnd()
3431 rajveer 13082 
    if self.ex is not None:
94 ashish 13083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13084 
      self.ex.write(oprot)
13085 
      oprot.writeFieldEnd()
13086 
    oprot.writeFieldStop()
13087 
    oprot.writeStructEnd()
13088 
 
3431 rajveer 13089 
  def validate(self):
13090 
    return
13091 
 
13092 
 
94 ashish 13093 
  def __repr__(self):
13094 
    L = ['%s=%r' % (key, value)
13095 
      for key, value in self.__dict__.iteritems()]
13096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13097 
 
13098 
  def __eq__(self, other):
13099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13100 
 
13101 
  def __ne__(self, other):
13102 
    return not (self == other)
13103 
 
4999 phani.kuma 13104 
class getOrderList_args:
13105 
  """
13106 
  Attributes:
13107 
   - order_ids
13108 
  """
13109 
 
13110 
  thrift_spec = (
13111 
    None, # 0
13112 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
13113 
  )
13114 
 
13115 
  def __init__(self, order_ids=None,):
13116 
    self.order_ids = order_ids
13117 
 
13118 
  def read(self, iprot):
13119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13121 
      return
13122 
    iprot.readStructBegin()
13123 
    while True:
13124 
      (fname, ftype, fid) = iprot.readFieldBegin()
13125 
      if ftype == TType.STOP:
13126 
        break
13127 
      if fid == 1:
13128 
        if ftype == TType.LIST:
13129 
          self.order_ids = []
6188 rajveer 13130 
          (_etype214, _size211) = iprot.readListBegin()
13131 
          for _i215 in xrange(_size211):
13132 
            _elem216 = iprot.readI64();
13133 
            self.order_ids.append(_elem216)
4999 phani.kuma 13134 
          iprot.readListEnd()
13135 
        else:
13136 
          iprot.skip(ftype)
13137 
      else:
13138 
        iprot.skip(ftype)
13139 
      iprot.readFieldEnd()
13140 
    iprot.readStructEnd()
13141 
 
13142 
  def write(self, oprot):
13143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13145 
      return
13146 
    oprot.writeStructBegin('getOrderList_args')
13147 
    if self.order_ids is not None:
13148 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
13149 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 13150 
      for iter217 in self.order_ids:
13151 
        oprot.writeI64(iter217)
4999 phani.kuma 13152 
      oprot.writeListEnd()
13153 
      oprot.writeFieldEnd()
13154 
    oprot.writeFieldStop()
13155 
    oprot.writeStructEnd()
13156 
 
13157 
  def validate(self):
13158 
    return
13159 
 
13160 
 
13161 
  def __repr__(self):
13162 
    L = ['%s=%r' % (key, value)
13163 
      for key, value in self.__dict__.iteritems()]
13164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13165 
 
13166 
  def __eq__(self, other):
13167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13168 
 
13169 
  def __ne__(self, other):
13170 
    return not (self == other)
13171 
 
13172 
class getOrderList_result:
13173 
  """
13174 
  Attributes:
13175 
   - success
13176 
  """
13177 
 
13178 
  thrift_spec = (
13179 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13180 
  )
13181 
 
13182 
  def __init__(self, success=None,):
13183 
    self.success = success
13184 
 
13185 
  def read(self, iprot):
13186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13188 
      return
13189 
    iprot.readStructBegin()
13190 
    while True:
13191 
      (fname, ftype, fid) = iprot.readFieldBegin()
13192 
      if ftype == TType.STOP:
13193 
        break
13194 
      if fid == 0:
13195 
        if ftype == TType.LIST:
13196 
          self.success = []
6188 rajveer 13197 
          (_etype221, _size218) = iprot.readListBegin()
13198 
          for _i222 in xrange(_size218):
13199 
            _elem223 = Order()
13200 
            _elem223.read(iprot)
13201 
            self.success.append(_elem223)
4999 phani.kuma 13202 
          iprot.readListEnd()
13203 
        else:
13204 
          iprot.skip(ftype)
13205 
      else:
13206 
        iprot.skip(ftype)
13207 
      iprot.readFieldEnd()
13208 
    iprot.readStructEnd()
13209 
 
13210 
  def write(self, oprot):
13211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13213 
      return
13214 
    oprot.writeStructBegin('getOrderList_result')
13215 
    if self.success is not None:
13216 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13217 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13218 
      for iter224 in self.success:
13219 
        iter224.write(oprot)
4999 phani.kuma 13220 
      oprot.writeListEnd()
13221 
      oprot.writeFieldEnd()
13222 
    oprot.writeFieldStop()
13223 
    oprot.writeStructEnd()
13224 
 
13225 
  def validate(self):
13226 
    return
13227 
 
13228 
 
13229 
  def __repr__(self):
13230 
    L = ['%s=%r' % (key, value)
13231 
      for key, value in self.__dict__.iteritems()]
13232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13233 
 
13234 
  def __eq__(self, other):
13235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13236 
 
13237 
  def __ne__(self, other):
13238 
    return not (self == other)
13239 
 
5386 phani.kuma 13240 
class getOrderListForVendor_args:
13241 
  """
13242 
  Attributes:
13243 
   - order_ids
13244 
   - vendorId
13245 
  """
13246 
 
13247 
  thrift_spec = (
13248 
    None, # 0
13249 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
13250 
    (2, TType.I64, 'vendorId', None, None, ), # 2
13251 
  )
13252 
 
13253 
  def __init__(self, order_ids=None, vendorId=None,):
13254 
    self.order_ids = order_ids
13255 
    self.vendorId = vendorId
13256 
 
13257 
  def read(self, iprot):
13258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13260 
      return
13261 
    iprot.readStructBegin()
13262 
    while True:
13263 
      (fname, ftype, fid) = iprot.readFieldBegin()
13264 
      if ftype == TType.STOP:
13265 
        break
13266 
      if fid == 1:
13267 
        if ftype == TType.LIST:
13268 
          self.order_ids = []
6188 rajveer 13269 
          (_etype228, _size225) = iprot.readListBegin()
13270 
          for _i229 in xrange(_size225):
13271 
            _elem230 = iprot.readI64();
13272 
            self.order_ids.append(_elem230)
5386 phani.kuma 13273 
          iprot.readListEnd()
13274 
        else:
13275 
          iprot.skip(ftype)
13276 
      elif fid == 2:
13277 
        if ftype == TType.I64:
13278 
          self.vendorId = iprot.readI64();
13279 
        else:
13280 
          iprot.skip(ftype)
13281 
      else:
13282 
        iprot.skip(ftype)
13283 
      iprot.readFieldEnd()
13284 
    iprot.readStructEnd()
13285 
 
13286 
  def write(self, oprot):
13287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13289 
      return
13290 
    oprot.writeStructBegin('getOrderListForVendor_args')
13291 
    if self.order_ids is not None:
13292 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
13293 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 13294 
      for iter231 in self.order_ids:
13295 
        oprot.writeI64(iter231)
5386 phani.kuma 13296 
      oprot.writeListEnd()
13297 
      oprot.writeFieldEnd()
13298 
    if self.vendorId is not None:
13299 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
13300 
      oprot.writeI64(self.vendorId)
13301 
      oprot.writeFieldEnd()
13302 
    oprot.writeFieldStop()
13303 
    oprot.writeStructEnd()
13304 
 
13305 
  def validate(self):
13306 
    return
13307 
 
13308 
 
13309 
  def __repr__(self):
13310 
    L = ['%s=%r' % (key, value)
13311 
      for key, value in self.__dict__.iteritems()]
13312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13313 
 
13314 
  def __eq__(self, other):
13315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13316 
 
13317 
  def __ne__(self, other):
13318 
    return not (self == other)
13319 
 
13320 
class getOrderListForVendor_result:
13321 
  """
13322 
  Attributes:
13323 
   - success
13324 
  """
13325 
 
13326 
  thrift_spec = (
13327 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13328 
  )
13329 
 
13330 
  def __init__(self, success=None,):
13331 
    self.success = success
13332 
 
13333 
  def read(self, iprot):
13334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13336 
      return
13337 
    iprot.readStructBegin()
13338 
    while True:
13339 
      (fname, ftype, fid) = iprot.readFieldBegin()
13340 
      if ftype == TType.STOP:
13341 
        break
13342 
      if fid == 0:
13343 
        if ftype == TType.LIST:
13344 
          self.success = []
6188 rajveer 13345 
          (_etype235, _size232) = iprot.readListBegin()
13346 
          for _i236 in xrange(_size232):
13347 
            _elem237 = Order()
13348 
            _elem237.read(iprot)
13349 
            self.success.append(_elem237)
5386 phani.kuma 13350 
          iprot.readListEnd()
13351 
        else:
13352 
          iprot.skip(ftype)
13353 
      else:
13354 
        iprot.skip(ftype)
13355 
      iprot.readFieldEnd()
13356 
    iprot.readStructEnd()
13357 
 
13358 
  def write(self, oprot):
13359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13361 
      return
13362 
    oprot.writeStructBegin('getOrderListForVendor_result')
13363 
    if self.success is not None:
13364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13365 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13366 
      for iter238 in self.success:
13367 
        iter238.write(oprot)
5386 phani.kuma 13368 
      oprot.writeListEnd()
13369 
      oprot.writeFieldEnd()
13370 
    oprot.writeFieldStop()
13371 
    oprot.writeStructEnd()
13372 
 
13373 
  def validate(self):
13374 
    return
13375 
 
13376 
 
13377 
  def __repr__(self):
13378 
    L = ['%s=%r' % (key, value)
13379 
      for key, value in self.__dict__.iteritems()]
13380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13381 
 
13382 
  def __eq__(self, other):
13383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13384 
 
13385 
  def __ne__(self, other):
13386 
    return not (self == other)
13387 
 
3064 chandransh 13388 
class getOrderForCustomer_args:
94 ashish 13389 
  """
13390 
  Attributes:
3064 chandransh 13391 
   - orderId
483 rajveer 13392 
   - customerId
94 ashish 13393 
  """
13394 
 
13395 
  thrift_spec = (
13396 
    None, # 0
3064 chandransh 13397 
    (1, TType.I64, 'orderId', None, None, ), # 1
13398 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 13399 
  )
13400 
 
3064 chandransh 13401 
  def __init__(self, orderId=None, customerId=None,):
13402 
    self.orderId = orderId
483 rajveer 13403 
    self.customerId = customerId
94 ashish 13404 
 
13405 
  def read(self, iprot):
13406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13408 
      return
13409 
    iprot.readStructBegin()
13410 
    while True:
13411 
      (fname, ftype, fid) = iprot.readFieldBegin()
13412 
      if ftype == TType.STOP:
13413 
        break
13414 
      if fid == 1:
13415 
        if ftype == TType.I64:
3064 chandransh 13416 
          self.orderId = iprot.readI64();
94 ashish 13417 
        else:
13418 
          iprot.skip(ftype)
13419 
      elif fid == 2:
13420 
        if ftype == TType.I64:
3064 chandransh 13421 
          self.customerId = iprot.readI64();
94 ashish 13422 
        else:
13423 
          iprot.skip(ftype)
13424 
      else:
13425 
        iprot.skip(ftype)
13426 
      iprot.readFieldEnd()
13427 
    iprot.readStructEnd()
13428 
 
13429 
  def write(self, oprot):
13430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13432 
      return
3064 chandransh 13433 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 13434 
    if self.orderId is not None:
3064 chandransh 13435 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13436 
      oprot.writeI64(self.orderId)
13437 
      oprot.writeFieldEnd()
3431 rajveer 13438 
    if self.customerId is not None:
3064 chandransh 13439 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 13440 
      oprot.writeI64(self.customerId)
94 ashish 13441 
      oprot.writeFieldEnd()
13442 
    oprot.writeFieldStop()
13443 
    oprot.writeStructEnd()
13444 
 
3431 rajveer 13445 
  def validate(self):
13446 
    return
13447 
 
13448 
 
94 ashish 13449 
  def __repr__(self):
13450 
    L = ['%s=%r' % (key, value)
13451 
      for key, value in self.__dict__.iteritems()]
13452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13453 
 
13454 
  def __eq__(self, other):
13455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13456 
 
13457 
  def __ne__(self, other):
13458 
    return not (self == other)
13459 
 
3064 chandransh 13460 
class getOrderForCustomer_result:
94 ashish 13461 
  """
13462 
  Attributes:
13463 
   - success
13464 
   - ex
13465 
  """
13466 
 
13467 
  thrift_spec = (
3064 chandransh 13468 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 13469 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13470 
  )
13471 
 
13472 
  def __init__(self, success=None, ex=None,):
13473 
    self.success = success
13474 
    self.ex = ex
13475 
 
13476 
  def read(self, iprot):
13477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13479 
      return
13480 
    iprot.readStructBegin()
13481 
    while True:
13482 
      (fname, ftype, fid) = iprot.readFieldBegin()
13483 
      if ftype == TType.STOP:
13484 
        break
13485 
      if fid == 0:
3064 chandransh 13486 
        if ftype == TType.STRUCT:
13487 
          self.success = Order()
13488 
          self.success.read(iprot)
94 ashish 13489 
        else:
13490 
          iprot.skip(ftype)
13491 
      elif fid == 1:
13492 
        if ftype == TType.STRUCT:
13493 
          self.ex = TransactionServiceException()
13494 
          self.ex.read(iprot)
13495 
        else:
13496 
          iprot.skip(ftype)
13497 
      else:
13498 
        iprot.skip(ftype)
13499 
      iprot.readFieldEnd()
13500 
    iprot.readStructEnd()
13501 
 
13502 
  def write(self, oprot):
13503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13505 
      return
3064 chandransh 13506 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 13507 
    if self.success is not None:
3064 chandransh 13508 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13509 
      self.success.write(oprot)
94 ashish 13510 
      oprot.writeFieldEnd()
3431 rajveer 13511 
    if self.ex is not None:
94 ashish 13512 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13513 
      self.ex.write(oprot)
13514 
      oprot.writeFieldEnd()
13515 
    oprot.writeFieldStop()
13516 
    oprot.writeStructEnd()
13517 
 
3431 rajveer 13518 
  def validate(self):
13519 
    return
13520 
 
13521 
 
94 ashish 13522 
  def __repr__(self):
13523 
    L = ['%s=%r' % (key, value)
13524 
      for key, value in self.__dict__.iteritems()]
13525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13526 
 
13527 
  def __eq__(self, other):
13528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13529 
 
13530 
  def __ne__(self, other):
13531 
    return not (self == other)
13532 
 
3064 chandransh 13533 
class getAlerts_args:
94 ashish 13534 
  """
13535 
  Attributes:
4394 rajveer 13536 
   - type
4444 rajveer 13537 
   - warehouseId
4394 rajveer 13538 
   - status
13539 
   - timestamp
94 ashish 13540 
  """
13541 
 
13542 
  thrift_spec = (
13543 
    None, # 0
4394 rajveer 13544 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13545 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13546 
    (3, TType.I64, 'status', None, None, ), # 3
13547 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 13548 
  )
13549 
 
4444 rajveer 13550 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 13551 
    self.type = type
4444 rajveer 13552 
    self.warehouseId = warehouseId
4394 rajveer 13553 
    self.status = status
13554 
    self.timestamp = timestamp
94 ashish 13555 
 
13556 
  def read(self, iprot):
13557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13559 
      return
13560 
    iprot.readStructBegin()
13561 
    while True:
13562 
      (fname, ftype, fid) = iprot.readFieldBegin()
13563 
      if ftype == TType.STOP:
13564 
        break
13565 
      if fid == 1:
3064 chandransh 13566 
        if ftype == TType.I64:
4394 rajveer 13567 
          self.type = iprot.readI64();
94 ashish 13568 
        else:
13569 
          iprot.skip(ftype)
3064 chandransh 13570 
      elif fid == 2:
4394 rajveer 13571 
        if ftype == TType.I64:
4444 rajveer 13572 
          self.warehouseId = iprot.readI64();
3064 chandransh 13573 
        else:
13574 
          iprot.skip(ftype)
4394 rajveer 13575 
      elif fid == 3:
13576 
        if ftype == TType.I64:
4444 rajveer 13577 
          self.status = iprot.readI64();
13578 
        else:
13579 
          iprot.skip(ftype)
13580 
      elif fid == 4:
13581 
        if ftype == TType.I64:
4394 rajveer 13582 
          self.timestamp = iprot.readI64();
13583 
        else:
13584 
          iprot.skip(ftype)
94 ashish 13585 
      else:
13586 
        iprot.skip(ftype)
13587 
      iprot.readFieldEnd()
13588 
    iprot.readStructEnd()
13589 
 
13590 
  def write(self, oprot):
13591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13593 
      return
3064 chandransh 13594 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 13595 
    if self.type is not None:
13596 
      oprot.writeFieldBegin('type', TType.I64, 1)
13597 
      oprot.writeI64(self.type)
94 ashish 13598 
      oprot.writeFieldEnd()
4444 rajveer 13599 
    if self.warehouseId is not None:
13600 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13601 
      oprot.writeI64(self.warehouseId)
13602 
      oprot.writeFieldEnd()
4394 rajveer 13603 
    if self.status is not None:
4444 rajveer 13604 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 13605 
      oprot.writeI64(self.status)
3064 chandransh 13606 
      oprot.writeFieldEnd()
4394 rajveer 13607 
    if self.timestamp is not None:
4444 rajveer 13608 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 13609 
      oprot.writeI64(self.timestamp)
13610 
      oprot.writeFieldEnd()
94 ashish 13611 
    oprot.writeFieldStop()
13612 
    oprot.writeStructEnd()
13613 
 
3431 rajveer 13614 
  def validate(self):
13615 
    return
13616 
 
13617 
 
94 ashish 13618 
  def __repr__(self):
13619 
    L = ['%s=%r' % (key, value)
13620 
      for key, value in self.__dict__.iteritems()]
13621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13622 
 
13623 
  def __eq__(self, other):
13624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13625 
 
13626 
  def __ne__(self, other):
13627 
    return not (self == other)
13628 
 
3064 chandransh 13629 
class getAlerts_result:
94 ashish 13630 
  """
13631 
  Attributes:
13632 
   - success
13633 
  """
13634 
 
13635 
  thrift_spec = (
3064 chandransh 13636 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 13637 
  )
13638 
 
3064 chandransh 13639 
  def __init__(self, success=None,):
94 ashish 13640 
    self.success = success
13641 
 
13642 
  def read(self, iprot):
13643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13645 
      return
13646 
    iprot.readStructBegin()
13647 
    while True:
13648 
      (fname, ftype, fid) = iprot.readFieldBegin()
13649 
      if ftype == TType.STOP:
13650 
        break
13651 
      if fid == 0:
3064 chandransh 13652 
        if ftype == TType.LIST:
13653 
          self.success = []
6188 rajveer 13654 
          (_etype242, _size239) = iprot.readListBegin()
13655 
          for _i243 in xrange(_size239):
13656 
            _elem244 = Alert()
13657 
            _elem244.read(iprot)
13658 
            self.success.append(_elem244)
3064 chandransh 13659 
          iprot.readListEnd()
94 ashish 13660 
        else:
13661 
          iprot.skip(ftype)
13662 
      else:
13663 
        iprot.skip(ftype)
13664 
      iprot.readFieldEnd()
13665 
    iprot.readStructEnd()
13666 
 
13667 
  def write(self, oprot):
13668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13670 
      return
3064 chandransh 13671 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13672 
    if self.success is not None:
3064 chandransh 13673 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13674 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13675 
      for iter245 in self.success:
13676 
        iter245.write(oprot)
3064 chandransh 13677 
      oprot.writeListEnd()
94 ashish 13678 
      oprot.writeFieldEnd()
13679 
    oprot.writeFieldStop()
13680 
    oprot.writeStructEnd()
13681 
 
3431 rajveer 13682 
  def validate(self):
13683 
    return
13684 
 
13685 
 
94 ashish 13686 
  def __repr__(self):
13687 
    L = ['%s=%r' % (key, value)
13688 
      for key, value in self.__dict__.iteritems()]
13689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13690 
 
13691 
  def __eq__(self, other):
13692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13693 
 
13694 
  def __ne__(self, other):
13695 
    return not (self == other)
13696 
 
4394 rajveer 13697 
class addAlert_args:
94 ashish 13698 
  """
13699 
  Attributes:
3064 chandransh 13700 
   - type
4444 rajveer 13701 
   - warehouseId
4394 rajveer 13702 
   - description
94 ashish 13703 
  """
13704 
 
13705 
  thrift_spec = (
13706 
    None, # 0
4394 rajveer 13707 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13708 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13709 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13710 
  )
13711 
 
4444 rajveer 13712 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13713 
    self.type = type
4444 rajveer 13714 
    self.warehouseId = warehouseId
4394 rajveer 13715 
    self.description = description
94 ashish 13716 
 
13717 
  def read(self, iprot):
13718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13720 
      return
13721 
    iprot.readStructBegin()
13722 
    while True:
13723 
      (fname, ftype, fid) = iprot.readFieldBegin()
13724 
      if ftype == TType.STOP:
13725 
        break
13726 
      if fid == 1:
13727 
        if ftype == TType.I64:
4394 rajveer 13728 
          self.type = iprot.readI64();
94 ashish 13729 
        else:
13730 
          iprot.skip(ftype)
3064 chandransh 13731 
      elif fid == 2:
4444 rajveer 13732 
        if ftype == TType.I64:
13733 
          self.warehouseId = iprot.readI64();
13734 
        else:
13735 
          iprot.skip(ftype)
13736 
      elif fid == 3:
3064 chandransh 13737 
        if ftype == TType.STRING:
4394 rajveer 13738 
          self.description = iprot.readString();
3064 chandransh 13739 
        else:
13740 
          iprot.skip(ftype)
94 ashish 13741 
      else:
13742 
        iprot.skip(ftype)
13743 
      iprot.readFieldEnd()
13744 
    iprot.readStructEnd()
13745 
 
13746 
  def write(self, oprot):
13747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13749 
      return
4394 rajveer 13750 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13751 
    if self.type is not None:
4394 rajveer 13752 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13753 
      oprot.writeI64(self.type)
13754 
      oprot.writeFieldEnd()
4444 rajveer 13755 
    if self.warehouseId is not None:
13756 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13757 
      oprot.writeI64(self.warehouseId)
13758 
      oprot.writeFieldEnd()
4394 rajveer 13759 
    if self.description is not None:
4444 rajveer 13760 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13761 
      oprot.writeString(self.description)
3064 chandransh 13762 
      oprot.writeFieldEnd()
94 ashish 13763 
    oprot.writeFieldStop()
13764 
    oprot.writeStructEnd()
13765 
 
3431 rajveer 13766 
  def validate(self):
13767 
    return
13768 
 
13769 
 
94 ashish 13770 
  def __repr__(self):
13771 
    L = ['%s=%r' % (key, value)
13772 
      for key, value in self.__dict__.iteritems()]
13773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13774 
 
13775 
  def __eq__(self, other):
13776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13777 
 
13778 
  def __ne__(self, other):
13779 
    return not (self == other)
13780 
 
4394 rajveer 13781 
class addAlert_result:
3064 chandransh 13782 
 
13783 
  thrift_spec = (
13784 
  )
13785 
 
13786 
  def read(self, iprot):
13787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13789 
      return
13790 
    iprot.readStructBegin()
13791 
    while True:
13792 
      (fname, ftype, fid) = iprot.readFieldBegin()
13793 
      if ftype == TType.STOP:
13794 
        break
13795 
      else:
13796 
        iprot.skip(ftype)
13797 
      iprot.readFieldEnd()
13798 
    iprot.readStructEnd()
13799 
 
13800 
  def write(self, oprot):
13801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13803 
      return
4394 rajveer 13804 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13805 
    oprot.writeFieldStop()
13806 
    oprot.writeStructEnd()
13807 
 
3431 rajveer 13808 
  def validate(self):
13809 
    return
13810 
 
13811 
 
3064 chandransh 13812 
  def __repr__(self):
13813 
    L = ['%s=%r' % (key, value)
13814 
      for key, value in self.__dict__.iteritems()]
13815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13816 
 
13817 
  def __eq__(self, other):
13818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13819 
 
13820 
  def __ne__(self, other):
13821 
    return not (self == other)
13822 
 
4444 rajveer 13823 
class markAlertsAsSeen_args:
13824 
  """
13825 
  Attributes:
13826 
   - warehouseId
13827 
  """
13828 
 
13829 
  thrift_spec = (
13830 
    None, # 0
13831 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13832 
  )
13833 
 
13834 
  def __init__(self, warehouseId=None,):
13835 
    self.warehouseId = warehouseId
13836 
 
13837 
  def read(self, iprot):
13838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13840 
      return
13841 
    iprot.readStructBegin()
13842 
    while True:
13843 
      (fname, ftype, fid) = iprot.readFieldBegin()
13844 
      if ftype == TType.STOP:
13845 
        break
13846 
      if fid == 1:
13847 
        if ftype == TType.I64:
13848 
          self.warehouseId = iprot.readI64();
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
13860 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13861 
    if self.warehouseId is not None:
13862 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13863 
      oprot.writeI64(self.warehouseId)
13864 
      oprot.writeFieldEnd()
13865 
    oprot.writeFieldStop()
13866 
    oprot.writeStructEnd()
13867 
 
13868 
  def validate(self):
13869 
    return
13870 
 
13871 
 
13872 
  def __repr__(self):
13873 
    L = ['%s=%r' % (key, value)
13874 
      for key, value in self.__dict__.iteritems()]
13875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13876 
 
13877 
  def __eq__(self, other):
13878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13879 
 
13880 
  def __ne__(self, other):
13881 
    return not (self == other)
13882 
 
13883 
class markAlertsAsSeen_result:
13884 
 
13885 
  thrift_spec = (
13886 
  )
13887 
 
13888 
  def read(self, iprot):
13889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13891 
      return
13892 
    iprot.readStructBegin()
13893 
    while True:
13894 
      (fname, ftype, fid) = iprot.readFieldBegin()
13895 
      if ftype == TType.STOP:
13896 
        break
13897 
      else:
13898 
        iprot.skip(ftype)
13899 
      iprot.readFieldEnd()
13900 
    iprot.readStructEnd()
13901 
 
13902 
  def write(self, oprot):
13903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13905 
      return
13906 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13907 
    oprot.writeFieldStop()
13908 
    oprot.writeStructEnd()
13909 
 
13910 
  def validate(self):
13911 
    return
13912 
 
13913 
 
13914 
  def __repr__(self):
13915 
    L = ['%s=%r' % (key, value)
13916 
      for key, value in self.__dict__.iteritems()]
13917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13918 
 
13919 
  def __eq__(self, other):
13920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13921 
 
13922 
  def __ne__(self, other):
13923 
    return not (self == other)
13924 
 
3064 chandransh 13925 
class getValidOrderCount_args:
13926 
 
13927 
  thrift_spec = (
13928 
  )
13929 
 
13930 
  def read(self, iprot):
13931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13933 
      return
13934 
    iprot.readStructBegin()
13935 
    while True:
13936 
      (fname, ftype, fid) = iprot.readFieldBegin()
13937 
      if ftype == TType.STOP:
13938 
        break
13939 
      else:
13940 
        iprot.skip(ftype)
13941 
      iprot.readFieldEnd()
13942 
    iprot.readStructEnd()
13943 
 
13944 
  def write(self, oprot):
13945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13947 
      return
13948 
    oprot.writeStructBegin('getValidOrderCount_args')
13949 
    oprot.writeFieldStop()
13950 
    oprot.writeStructEnd()
13951 
 
3431 rajveer 13952 
  def validate(self):
13953 
    return
13954 
 
13955 
 
3064 chandransh 13956 
  def __repr__(self):
13957 
    L = ['%s=%r' % (key, value)
13958 
      for key, value in self.__dict__.iteritems()]
13959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13960 
 
13961 
  def __eq__(self, other):
13962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13963 
 
13964 
  def __ne__(self, other):
13965 
    return not (self == other)
13966 
 
13967 
class getValidOrderCount_result:
94 ashish 13968 
  """
13969 
  Attributes:
13970 
   - success
13971 
  """
13972 
 
13973 
  thrift_spec = (
3064 chandransh 13974 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13975 
  )
13976 
 
3064 chandransh 13977 
  def __init__(self, success=None,):
94 ashish 13978 
    self.success = success
13979 
 
13980 
  def read(self, iprot):
13981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13983 
      return
13984 
    iprot.readStructBegin()
13985 
    while True:
13986 
      (fname, ftype, fid) = iprot.readFieldBegin()
13987 
      if ftype == TType.STOP:
13988 
        break
13989 
      if fid == 0:
3064 chandransh 13990 
        if ftype == TType.I64:
13991 
          self.success = iprot.readI64();
94 ashish 13992 
        else:
13993 
          iprot.skip(ftype)
13994 
      else:
13995 
        iprot.skip(ftype)
13996 
      iprot.readFieldEnd()
13997 
    iprot.readStructEnd()
13998 
 
13999 
  def write(self, oprot):
14000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14002 
      return
3064 chandransh 14003 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 14004 
    if self.success is not None:
3064 chandransh 14005 
      oprot.writeFieldBegin('success', TType.I64, 0)
14006 
      oprot.writeI64(self.success)
94 ashish 14007 
      oprot.writeFieldEnd()
14008 
    oprot.writeFieldStop()
14009 
    oprot.writeStructEnd()
14010 
 
3431 rajveer 14011 
  def validate(self):
14012 
    return
14013 
 
14014 
 
94 ashish 14015 
  def __repr__(self):
14016 
    L = ['%s=%r' % (key, value)
14017 
      for key, value in self.__dict__.iteritems()]
14018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14019 
 
14020 
  def __eq__(self, other):
14021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14022 
 
14023 
  def __ne__(self, other):
14024 
    return not (self == other)
14025 
 
3064 chandransh 14026 
class getNoOfCustomersWithSuccessfulTransaction_args:
14027 
 
14028 
  thrift_spec = (
14029 
  )
14030 
 
14031 
  def read(self, iprot):
14032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14034 
      return
14035 
    iprot.readStructBegin()
14036 
    while True:
14037 
      (fname, ftype, fid) = iprot.readFieldBegin()
14038 
      if ftype == TType.STOP:
14039 
        break
14040 
      else:
14041 
        iprot.skip(ftype)
14042 
      iprot.readFieldEnd()
14043 
    iprot.readStructEnd()
14044 
 
14045 
  def write(self, oprot):
14046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14048 
      return
14049 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
14050 
    oprot.writeFieldStop()
14051 
    oprot.writeStructEnd()
14052 
 
3431 rajveer 14053 
  def validate(self):
14054 
    return
14055 
 
14056 
 
3064 chandransh 14057 
  def __repr__(self):
14058 
    L = ['%s=%r' % (key, value)
14059 
      for key, value in self.__dict__.iteritems()]
14060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14061 
 
14062 
  def __eq__(self, other):
14063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14064 
 
14065 
  def __ne__(self, other):
14066 
    return not (self == other)
14067 
 
14068 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 14069 
  """
14070 
  Attributes:
3064 chandransh 14071 
   - success
94 ashish 14072 
  """
14073 
 
14074 
  thrift_spec = (
3064 chandransh 14075 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 14076 
  )
14077 
 
3064 chandransh 14078 
  def __init__(self, success=None,):
14079 
    self.success = success
94 ashish 14080 
 
14081 
  def read(self, iprot):
14082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14084 
      return
14085 
    iprot.readStructBegin()
14086 
    while True:
14087 
      (fname, ftype, fid) = iprot.readFieldBegin()
14088 
      if ftype == TType.STOP:
14089 
        break
3064 chandransh 14090 
      if fid == 0:
94 ashish 14091 
        if ftype == TType.I64:
3064 chandransh 14092 
          self.success = iprot.readI64();
94 ashish 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
3064 chandransh 14104 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 14105 
    if self.success is not None:
3064 chandransh 14106 
      oprot.writeFieldBegin('success', TType.I64, 0)
14107 
      oprot.writeI64(self.success)
94 ashish 14108 
      oprot.writeFieldEnd()
14109 
    oprot.writeFieldStop()
14110 
    oprot.writeStructEnd()
14111 
 
3431 rajveer 14112 
  def validate(self):
14113 
    return
14114 
 
14115 
 
94 ashish 14116 
  def __repr__(self):
14117 
    L = ['%s=%r' % (key, value)
14118 
      for key, value in self.__dict__.iteritems()]
14119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14120 
 
14121 
  def __eq__(self, other):
14122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14123 
 
14124 
  def __ne__(self, other):
14125 
    return not (self == other)
14126 
 
3064 chandransh 14127 
class getValidOrdersAmountRange_args:
14128 
 
14129 
  thrift_spec = (
14130 
  )
14131 
 
14132 
  def read(self, iprot):
14133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14135 
      return
14136 
    iprot.readStructBegin()
14137 
    while True:
14138 
      (fname, ftype, fid) = iprot.readFieldBegin()
14139 
      if ftype == TType.STOP:
14140 
        break
14141 
      else:
14142 
        iprot.skip(ftype)
14143 
      iprot.readFieldEnd()
14144 
    iprot.readStructEnd()
14145 
 
14146 
  def write(self, oprot):
14147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14149 
      return
14150 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
14151 
    oprot.writeFieldStop()
14152 
    oprot.writeStructEnd()
14153 
 
3431 rajveer 14154 
  def validate(self):
14155 
    return
14156 
 
14157 
 
3064 chandransh 14158 
  def __repr__(self):
14159 
    L = ['%s=%r' % (key, value)
14160 
      for key, value in self.__dict__.iteritems()]
14161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14162 
 
14163 
  def __eq__(self, other):
14164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14165 
 
14166 
  def __ne__(self, other):
14167 
    return not (self == other)
14168 
 
14169 
class getValidOrdersAmountRange_result:
94 ashish 14170 
  """
14171 
  Attributes:
14172 
   - success
14173 
  """
14174 
 
14175 
  thrift_spec = (
3064 chandransh 14176 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 14177 
  )
14178 
 
3064 chandransh 14179 
  def __init__(self, success=None,):
94 ashish 14180 
    self.success = success
14181 
 
14182 
  def read(self, iprot):
14183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14185 
      return
14186 
    iprot.readStructBegin()
14187 
    while True:
14188 
      (fname, ftype, fid) = iprot.readFieldBegin()
14189 
      if ftype == TType.STOP:
14190 
        break
14191 
      if fid == 0:
483 rajveer 14192 
        if ftype == TType.LIST:
14193 
          self.success = []
6188 rajveer 14194 
          (_etype249, _size246) = iprot.readListBegin()
14195 
          for _i250 in xrange(_size246):
14196 
            _elem251 = iprot.readDouble();
14197 
            self.success.append(_elem251)
483 rajveer 14198 
          iprot.readListEnd()
94 ashish 14199 
        else:
14200 
          iprot.skip(ftype)
14201 
      else:
14202 
        iprot.skip(ftype)
14203 
      iprot.readFieldEnd()
14204 
    iprot.readStructEnd()
14205 
 
14206 
  def write(self, oprot):
14207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14209 
      return
3064 chandransh 14210 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 14211 
    if self.success is not None:
483 rajveer 14212 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 14213 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 14214 
      for iter252 in self.success:
14215 
        oprot.writeDouble(iter252)
483 rajveer 14216 
      oprot.writeListEnd()
94 ashish 14217 
      oprot.writeFieldEnd()
14218 
    oprot.writeFieldStop()
14219 
    oprot.writeStructEnd()
14220 
 
3431 rajveer 14221 
  def validate(self):
14222 
    return
14223 
 
14224 
 
94 ashish 14225 
  def __repr__(self):
14226 
    L = ['%s=%r' % (key, value)
14227 
      for key, value in self.__dict__.iteritems()]
14228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14229 
 
14230 
  def __eq__(self, other):
14231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14232 
 
14233 
  def __ne__(self, other):
14234 
    return not (self == other)
14235 
 
3064 chandransh 14236 
class getValidOrders_args:
1528 ankur.sing 14237 
  """
14238 
  Attributes:
3064 chandransh 14239 
   - limit
5874 rajveer 14240 
   - onlyStore
1528 ankur.sing 14241 
  """
14242 
 
14243 
  thrift_spec = (
14244 
    None, # 0
3064 chandransh 14245 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 14246 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 14247 
  )
14248 
 
5874 rajveer 14249 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 14250 
    self.limit = limit
5874 rajveer 14251 
    self.onlyStore = onlyStore
1528 ankur.sing 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.I64:
3064 chandransh 14264 
          self.limit = iprot.readI64();
1528 ankur.sing 14265 
        else:
14266 
          iprot.skip(ftype)
5874 rajveer 14267 
      elif fid == 2:
14268 
        if ftype == TType.BOOL:
14269 
          self.onlyStore = iprot.readBool();
14270 
        else:
14271 
          iprot.skip(ftype)
1528 ankur.sing 14272 
      else:
14273 
        iprot.skip(ftype)
14274 
      iprot.readFieldEnd()
14275 
    iprot.readStructEnd()
14276 
 
14277 
  def write(self, oprot):
14278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14280 
      return
3064 chandransh 14281 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 14282 
    if self.limit is not None:
3064 chandransh 14283 
      oprot.writeFieldBegin('limit', TType.I64, 1)
14284 
      oprot.writeI64(self.limit)
1528 ankur.sing 14285 
      oprot.writeFieldEnd()
5874 rajveer 14286 
    if self.onlyStore is not None:
14287 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
14288 
      oprot.writeBool(self.onlyStore)
14289 
      oprot.writeFieldEnd()
1528 ankur.sing 14290 
    oprot.writeFieldStop()
14291 
    oprot.writeStructEnd()
14292 
 
3431 rajveer 14293 
  def validate(self):
14294 
    return
14295 
 
14296 
 
1528 ankur.sing 14297 
  def __repr__(self):
14298 
    L = ['%s=%r' % (key, value)
14299 
      for key, value in self.__dict__.iteritems()]
14300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14301 
 
14302 
  def __eq__(self, other):
14303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14304 
 
14305 
  def __ne__(self, other):
14306 
    return not (self == other)
14307 
 
3064 chandransh 14308 
class getValidOrders_result:
1528 ankur.sing 14309 
  """
14310 
  Attributes:
14311 
   - success
14312 
  """
14313 
 
14314 
  thrift_spec = (
3064 chandransh 14315 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 14316 
  )
14317 
 
3064 chandransh 14318 
  def __init__(self, success=None,):
1528 ankur.sing 14319 
    self.success = success
14320 
 
14321 
  def read(self, iprot):
14322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14324 
      return
14325 
    iprot.readStructBegin()
14326 
    while True:
14327 
      (fname, ftype, fid) = iprot.readFieldBegin()
14328 
      if ftype == TType.STOP:
14329 
        break
14330 
      if fid == 0:
3064 chandransh 14331 
        if ftype == TType.LIST:
14332 
          self.success = []
6188 rajveer 14333 
          (_etype256, _size253) = iprot.readListBegin()
14334 
          for _i257 in xrange(_size253):
14335 
            _elem258 = Order()
14336 
            _elem258.read(iprot)
14337 
            self.success.append(_elem258)
3064 chandransh 14338 
          iprot.readListEnd()
1528 ankur.sing 14339 
        else:
14340 
          iprot.skip(ftype)
14341 
      else:
14342 
        iprot.skip(ftype)
14343 
      iprot.readFieldEnd()
14344 
    iprot.readStructEnd()
14345 
 
14346 
  def write(self, oprot):
14347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14349 
      return
3064 chandransh 14350 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 14351 
    if self.success is not None:
3064 chandransh 14352 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14353 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14354 
      for iter259 in self.success:
14355 
        iter259.write(oprot)
3064 chandransh 14356 
      oprot.writeListEnd()
1528 ankur.sing 14357 
      oprot.writeFieldEnd()
14358 
    oprot.writeFieldStop()
14359 
    oprot.writeStructEnd()
14360 
 
3431 rajveer 14361 
  def validate(self):
14362 
    return
14363 
 
14364 
 
1528 ankur.sing 14365 
  def __repr__(self):
14366 
    L = ['%s=%r' % (key, value)
14367 
      for key, value in self.__dict__.iteritems()]
14368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14369 
 
14370 
  def __eq__(self, other):
14371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14372 
 
14373 
  def __ne__(self, other):
14374 
    return not (self == other)
14375 
 
1220 chandransh 14376 
class batchOrders_args:
14377 
  """
14378 
  Attributes:
14379 
   - warehouseId
14380 
  """
14381 
 
14382 
  thrift_spec = (
14383 
    None, # 0
14384 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14385 
  )
14386 
 
14387 
  def __init__(self, warehouseId=None,):
14388 
    self.warehouseId = warehouseId
14389 
 
14390 
  def read(self, iprot):
14391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14393 
      return
14394 
    iprot.readStructBegin()
14395 
    while True:
14396 
      (fname, ftype, fid) = iprot.readFieldBegin()
14397 
      if ftype == TType.STOP:
14398 
        break
14399 
      if fid == 1:
14400 
        if ftype == TType.I64:
14401 
          self.warehouseId = iprot.readI64();
14402 
        else:
14403 
          iprot.skip(ftype)
14404 
      else:
14405 
        iprot.skip(ftype)
14406 
      iprot.readFieldEnd()
14407 
    iprot.readStructEnd()
14408 
 
14409 
  def write(self, oprot):
14410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14412 
      return
14413 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 14414 
    if self.warehouseId is not None:
1220 chandransh 14415 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14416 
      oprot.writeI64(self.warehouseId)
14417 
      oprot.writeFieldEnd()
14418 
    oprot.writeFieldStop()
14419 
    oprot.writeStructEnd()
14420 
 
3431 rajveer 14421 
  def validate(self):
14422 
    return
14423 
 
14424 
 
1220 chandransh 14425 
  def __repr__(self):
14426 
    L = ['%s=%r' % (key, value)
14427 
      for key, value in self.__dict__.iteritems()]
14428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14429 
 
14430 
  def __eq__(self, other):
14431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14432 
 
14433 
  def __ne__(self, other):
14434 
    return not (self == other)
14435 
 
14436 
class batchOrders_result:
14437 
  """
14438 
  Attributes:
14439 
   - success
14440 
   - ex
14441 
  """
14442 
 
14443 
  thrift_spec = (
14444 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14446 
  )
14447 
 
14448 
  def __init__(self, success=None, ex=None,):
14449 
    self.success = success
14450 
    self.ex = ex
14451 
 
14452 
  def read(self, iprot):
14453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14455 
      return
14456 
    iprot.readStructBegin()
14457 
    while True:
14458 
      (fname, ftype, fid) = iprot.readFieldBegin()
14459 
      if ftype == TType.STOP:
14460 
        break
14461 
      if fid == 0:
14462 
        if ftype == TType.LIST:
14463 
          self.success = []
6188 rajveer 14464 
          (_etype263, _size260) = iprot.readListBegin()
14465 
          for _i264 in xrange(_size260):
14466 
            _elem265 = Order()
14467 
            _elem265.read(iprot)
14468 
            self.success.append(_elem265)
1220 chandransh 14469 
          iprot.readListEnd()
14470 
        else:
14471 
          iprot.skip(ftype)
14472 
      elif fid == 1:
14473 
        if ftype == TType.STRUCT:
14474 
          self.ex = TransactionServiceException()
14475 
          self.ex.read(iprot)
14476 
        else:
14477 
          iprot.skip(ftype)
14478 
      else:
14479 
        iprot.skip(ftype)
14480 
      iprot.readFieldEnd()
14481 
    iprot.readStructEnd()
14482 
 
14483 
  def write(self, oprot):
14484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14486 
      return
14487 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 14488 
    if self.success is not None:
1220 chandransh 14489 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14490 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14491 
      for iter266 in self.success:
14492 
        iter266.write(oprot)
1220 chandransh 14493 
      oprot.writeListEnd()
14494 
      oprot.writeFieldEnd()
3431 rajveer 14495 
    if self.ex is not None:
1220 chandransh 14496 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14497 
      self.ex.write(oprot)
14498 
      oprot.writeFieldEnd()
14499 
    oprot.writeFieldStop()
14500 
    oprot.writeStructEnd()
14501 
 
3431 rajveer 14502 
  def validate(self):
14503 
    return
14504 
 
14505 
 
1220 chandransh 14506 
  def __repr__(self):
14507 
    L = ['%s=%r' % (key, value)
14508 
      for key, value in self.__dict__.iteritems()]
14509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14510 
 
14511 
  def __eq__(self, other):
14512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14513 
 
14514 
  def __ne__(self, other):
14515 
    return not (self == other)
14516 
 
1208 chandransh 14517 
class markOrderAsOutOfStock_args:
14518 
  """
14519 
  Attributes:
14520 
   - orderId
14521 
  """
14522 
 
14523 
  thrift_spec = (
14524 
    None, # 0
14525 
    (1, TType.I64, 'orderId', None, None, ), # 1
14526 
  )
14527 
 
14528 
  def __init__(self, orderId=None,):
14529 
    self.orderId = orderId
14530 
 
14531 
  def read(self, iprot):
14532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14534 
      return
14535 
    iprot.readStructBegin()
14536 
    while True:
14537 
      (fname, ftype, fid) = iprot.readFieldBegin()
14538 
      if ftype == TType.STOP:
14539 
        break
14540 
      if fid == 1:
14541 
        if ftype == TType.I64:
14542 
          self.orderId = iprot.readI64();
14543 
        else:
14544 
          iprot.skip(ftype)
14545 
      else:
14546 
        iprot.skip(ftype)
14547 
      iprot.readFieldEnd()
14548 
    iprot.readStructEnd()
14549 
 
14550 
  def write(self, oprot):
14551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14553 
      return
14554 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 14555 
    if self.orderId is not None:
1208 chandransh 14556 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14557 
      oprot.writeI64(self.orderId)
14558 
      oprot.writeFieldEnd()
14559 
    oprot.writeFieldStop()
14560 
    oprot.writeStructEnd()
14561 
 
3431 rajveer 14562 
  def validate(self):
14563 
    return
14564 
 
14565 
 
1208 chandransh 14566 
  def __repr__(self):
14567 
    L = ['%s=%r' % (key, value)
14568 
      for key, value in self.__dict__.iteritems()]
14569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14570 
 
14571 
  def __eq__(self, other):
14572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14573 
 
14574 
  def __ne__(self, other):
14575 
    return not (self == other)
14576 
 
14577 
class markOrderAsOutOfStock_result:
14578 
  """
14579 
  Attributes:
14580 
   - success
14581 
   - ex
14582 
  """
14583 
 
14584 
  thrift_spec = (
14585 
    (0, TType.BOOL, 'success', None, None, ), # 0
14586 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14587 
  )
14588 
 
14589 
  def __init__(self, success=None, ex=None,):
14590 
    self.success = success
14591 
    self.ex = ex
14592 
 
14593 
  def read(self, iprot):
14594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14596 
      return
14597 
    iprot.readStructBegin()
14598 
    while True:
14599 
      (fname, ftype, fid) = iprot.readFieldBegin()
14600 
      if ftype == TType.STOP:
14601 
        break
14602 
      if fid == 0:
14603 
        if ftype == TType.BOOL:
14604 
          self.success = iprot.readBool();
14605 
        else:
14606 
          iprot.skip(ftype)
14607 
      elif fid == 1:
14608 
        if ftype == TType.STRUCT:
14609 
          self.ex = TransactionServiceException()
14610 
          self.ex.read(iprot)
14611 
        else:
14612 
          iprot.skip(ftype)
14613 
      else:
14614 
        iprot.skip(ftype)
14615 
      iprot.readFieldEnd()
14616 
    iprot.readStructEnd()
14617 
 
14618 
  def write(self, oprot):
14619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14621 
      return
14622 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 14623 
    if self.success is not None:
1208 chandransh 14624 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14625 
      oprot.writeBool(self.success)
14626 
      oprot.writeFieldEnd()
3431 rajveer 14627 
    if self.ex is not None:
1208 chandransh 14628 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14629 
      self.ex.write(oprot)
14630 
      oprot.writeFieldEnd()
14631 
    oprot.writeFieldStop()
14632 
    oprot.writeStructEnd()
14633 
 
3431 rajveer 14634 
  def validate(self):
14635 
    return
14636 
 
14637 
 
1208 chandransh 14638 
  def __repr__(self):
14639 
    L = ['%s=%r' % (key, value)
14640 
      for key, value in self.__dict__.iteritems()]
14641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14642 
 
14643 
  def __eq__(self, other):
14644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14645 
 
14646 
  def __ne__(self, other):
14647 
    return not (self == other)
14648 
 
3064 chandransh 14649 
class verifyOrder_args:
759 chandransh 14650 
  """
14651 
  Attributes:
3064 chandransh 14652 
   - orderId
759 chandransh 14653 
  """
14654 
 
14655 
  thrift_spec = (
14656 
    None, # 0
3064 chandransh 14657 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 14658 
  )
14659 
 
3064 chandransh 14660 
  def __init__(self, orderId=None,):
14661 
    self.orderId = orderId
759 chandransh 14662 
 
14663 
  def read(self, iprot):
14664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14666 
      return
14667 
    iprot.readStructBegin()
14668 
    while True:
14669 
      (fname, ftype, fid) = iprot.readFieldBegin()
14670 
      if ftype == TType.STOP:
14671 
        break
14672 
      if fid == 1:
14673 
        if ftype == TType.I64:
3064 chandransh 14674 
          self.orderId = iprot.readI64();
759 chandransh 14675 
        else:
14676 
          iprot.skip(ftype)
14677 
      else:
14678 
        iprot.skip(ftype)
14679 
      iprot.readFieldEnd()
14680 
    iprot.readStructEnd()
14681 
 
14682 
  def write(self, oprot):
14683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14685 
      return
3064 chandransh 14686 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14687 
    if self.orderId is not None:
3064 chandransh 14688 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14689 
      oprot.writeI64(self.orderId)
759 chandransh 14690 
      oprot.writeFieldEnd()
14691 
    oprot.writeFieldStop()
14692 
    oprot.writeStructEnd()
14693 
 
3431 rajveer 14694 
  def validate(self):
14695 
    return
14696 
 
14697 
 
759 chandransh 14698 
  def __repr__(self):
14699 
    L = ['%s=%r' % (key, value)
14700 
      for key, value in self.__dict__.iteritems()]
14701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14702 
 
14703 
  def __eq__(self, other):
14704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14705 
 
14706 
  def __ne__(self, other):
14707 
    return not (self == other)
14708 
 
3064 chandransh 14709 
class verifyOrder_result:
759 chandransh 14710 
  """
14711 
  Attributes:
14712 
   - success
14713 
   - ex
14714 
  """
14715 
 
14716 
  thrift_spec = (
14717 
    (0, TType.BOOL, 'success', None, None, ), # 0
14718 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14719 
  )
14720 
 
14721 
  def __init__(self, success=None, ex=None,):
14722 
    self.success = success
14723 
    self.ex = ex
14724 
 
14725 
  def read(self, iprot):
14726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14728 
      return
14729 
    iprot.readStructBegin()
14730 
    while True:
14731 
      (fname, ftype, fid) = iprot.readFieldBegin()
14732 
      if ftype == TType.STOP:
14733 
        break
14734 
      if fid == 0:
14735 
        if ftype == TType.BOOL:
14736 
          self.success = iprot.readBool();
14737 
        else:
14738 
          iprot.skip(ftype)
14739 
      elif fid == 1:
14740 
        if ftype == TType.STRUCT:
14741 
          self.ex = TransactionServiceException()
14742 
          self.ex.read(iprot)
14743 
        else:
14744 
          iprot.skip(ftype)
14745 
      else:
14746 
        iprot.skip(ftype)
14747 
      iprot.readFieldEnd()
14748 
    iprot.readStructEnd()
14749 
 
14750 
  def write(self, oprot):
14751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14753 
      return
3064 chandransh 14754 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14755 
    if self.success is not None:
759 chandransh 14756 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14757 
      oprot.writeBool(self.success)
14758 
      oprot.writeFieldEnd()
3431 rajveer 14759 
    if self.ex is not None:
759 chandransh 14760 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14761 
      self.ex.write(oprot)
14762 
      oprot.writeFieldEnd()
14763 
    oprot.writeFieldStop()
14764 
    oprot.writeStructEnd()
14765 
 
3431 rajveer 14766 
  def validate(self):
14767 
    return
14768 
 
14769 
 
759 chandransh 14770 
  def __repr__(self):
14771 
    L = ['%s=%r' % (key, value)
14772 
      for key, value in self.__dict__.iteritems()]
14773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14774 
 
14775 
  def __eq__(self, other):
14776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14777 
 
14778 
  def __ne__(self, other):
14779 
    return not (self == other)
14780 
 
3064 chandransh 14781 
class acceptOrder_args:
1113 chandransh 14782 
  """
14783 
  Attributes:
3064 chandransh 14784 
   - orderId
1113 chandransh 14785 
  """
14786 
 
14787 
  thrift_spec = (
14788 
    None, # 0
3064 chandransh 14789 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14790 
  )
14791 
 
3064 chandransh 14792 
  def __init__(self, orderId=None,):
14793 
    self.orderId = orderId
1113 chandransh 14794 
 
14795 
  def read(self, iprot):
14796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14798 
      return
14799 
    iprot.readStructBegin()
14800 
    while True:
14801 
      (fname, ftype, fid) = iprot.readFieldBegin()
14802 
      if ftype == TType.STOP:
14803 
        break
14804 
      if fid == 1:
14805 
        if ftype == TType.I64:
3064 chandransh 14806 
          self.orderId = iprot.readI64();
1113 chandransh 14807 
        else:
14808 
          iprot.skip(ftype)
14809 
      else:
14810 
        iprot.skip(ftype)
14811 
      iprot.readFieldEnd()
14812 
    iprot.readStructEnd()
14813 
 
14814 
  def write(self, oprot):
14815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14817 
      return
3064 chandransh 14818 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14819 
    if self.orderId is not None:
3064 chandransh 14820 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14821 
      oprot.writeI64(self.orderId)
1113 chandransh 14822 
      oprot.writeFieldEnd()
14823 
    oprot.writeFieldStop()
14824 
    oprot.writeStructEnd()
14825 
 
3431 rajveer 14826 
  def validate(self):
14827 
    return
14828 
 
14829 
 
1113 chandransh 14830 
  def __repr__(self):
14831 
    L = ['%s=%r' % (key, value)
14832 
      for key, value in self.__dict__.iteritems()]
14833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14834 
 
14835 
  def __eq__(self, other):
14836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14837 
 
14838 
  def __ne__(self, other):
14839 
    return not (self == other)
14840 
 
3064 chandransh 14841 
class acceptOrder_result:
1113 chandransh 14842 
  """
14843 
  Attributes:
14844 
   - success
14845 
   - ex
14846 
  """
14847 
 
14848 
  thrift_spec = (
3064 chandransh 14849 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14851 
  )
14852 
 
14853 
  def __init__(self, success=None, ex=None,):
14854 
    self.success = success
14855 
    self.ex = ex
14856 
 
14857 
  def read(self, iprot):
14858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14860 
      return
14861 
    iprot.readStructBegin()
14862 
    while True:
14863 
      (fname, ftype, fid) = iprot.readFieldBegin()
14864 
      if ftype == TType.STOP:
14865 
        break
14866 
      if fid == 0:
3064 chandransh 14867 
        if ftype == TType.BOOL:
14868 
          self.success = iprot.readBool();
1113 chandransh 14869 
        else:
14870 
          iprot.skip(ftype)
14871 
      elif fid == 1:
14872 
        if ftype == TType.STRUCT:
14873 
          self.ex = TransactionServiceException()
14874 
          self.ex.read(iprot)
14875 
        else:
14876 
          iprot.skip(ftype)
14877 
      else:
14878 
        iprot.skip(ftype)
14879 
      iprot.readFieldEnd()
14880 
    iprot.readStructEnd()
14881 
 
14882 
  def write(self, oprot):
14883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14885 
      return
3064 chandransh 14886 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14887 
    if self.success is not None:
3064 chandransh 14888 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14889 
      oprot.writeBool(self.success)
1113 chandransh 14890 
      oprot.writeFieldEnd()
3431 rajveer 14891 
    if self.ex is not None:
1113 chandransh 14892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14893 
      self.ex.write(oprot)
14894 
      oprot.writeFieldEnd()
14895 
    oprot.writeFieldStop()
14896 
    oprot.writeStructEnd()
14897 
 
3431 rajveer 14898 
  def validate(self):
14899 
    return
14900 
 
14901 
 
1113 chandransh 14902 
  def __repr__(self):
14903 
    L = ['%s=%r' % (key, value)
14904 
      for key, value in self.__dict__.iteritems()]
14905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14906 
 
14907 
  def __eq__(self, other):
14908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14909 
 
14910 
  def __ne__(self, other):
14911 
    return not (self == other)
14912 
 
3064 chandransh 14913 
class addBillingDetails_args:
1135 chandransh 14914 
  """
14915 
  Attributes:
3064 chandransh 14916 
   - orderId
14917 
   - invoice_number
4658 mandeep.dh 14918 
   - serialNumber
4283 anupam.sin 14919 
   - itemNumber
7190 amar.kumar 14920 
   - freebieWarehouseId
3064 chandransh 14921 
   - billed_by
4264 rajveer 14922 
   - jacketNumber
4283 anupam.sin 14923 
   - billingType
5110 mandeep.dh 14924 
   - fulfilmentWarehouseId
4763 rajveer 14925 
   - authorize
1135 chandransh 14926 
  """
14927 
 
14928 
  thrift_spec = (
14929 
    None, # 0
3064 chandransh 14930 
    (1, TType.I64, 'orderId', None, None, ), # 1
14931 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14932 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14933 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
7190 amar.kumar 14934 
    (5, TType.I64, 'freebieWarehouseId', None, None, ), # 5
14935 
    (6, TType.STRING, 'billed_by', None, None, ), # 6
14936 
    (7, TType.I64, 'jacketNumber', None, None, ), # 7
14937 
    (8, TType.I64, 'billingType', None, None, ), # 8
14938 
    (9, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 9
14939 
    (10, TType.BOOL, 'authorize', None, None, ), # 10
1135 chandransh 14940 
  )
14941 
 
7190 amar.kumar 14942 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, freebieWarehouseId=None, billed_by=None, jacketNumber=None, billingType=None, fulfilmentWarehouseId=None, authorize=None,):
3064 chandransh 14943 
    self.orderId = orderId
14944 
    self.invoice_number = invoice_number
4658 mandeep.dh 14945 
    self.serialNumber = serialNumber
4283 anupam.sin 14946 
    self.itemNumber = itemNumber
7190 amar.kumar 14947 
    self.freebieWarehouseId = freebieWarehouseId
3064 chandransh 14948 
    self.billed_by = billed_by
4264 rajveer 14949 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14950 
    self.billingType = billingType
5110 mandeep.dh 14951 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14952 
    self.authorize = authorize
1135 chandransh 14953 
 
14954 
  def read(self, iprot):
14955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14957 
      return
14958 
    iprot.readStructBegin()
14959 
    while True:
14960 
      (fname, ftype, fid) = iprot.readFieldBegin()
14961 
      if ftype == TType.STOP:
14962 
        break
14963 
      if fid == 1:
14964 
        if ftype == TType.I64:
3064 chandransh 14965 
          self.orderId = iprot.readI64();
1135 chandransh 14966 
        else:
14967 
          iprot.skip(ftype)
14968 
      elif fid == 2:
3064 chandransh 14969 
        if ftype == TType.STRING:
14970 
          self.invoice_number = iprot.readString();
1135 chandransh 14971 
        else:
14972 
          iprot.skip(ftype)
3064 chandransh 14973 
      elif fid == 3:
5411 rajveer 14974 
        if ftype == TType.LIST:
14975 
          self.serialNumber = []
6188 rajveer 14976 
          (_etype270, _size267) = iprot.readListBegin()
14977 
          for _i271 in xrange(_size267):
14978 
            _elem272 = iprot.readString();
14979 
            self.serialNumber.append(_elem272)
5411 rajveer 14980 
          iprot.readListEnd()
3064 chandransh 14981 
        else:
14982 
          iprot.skip(ftype)
14983 
      elif fid == 4:
5411 rajveer 14984 
        if ftype == TType.LIST:
14985 
          self.itemNumber = []
6188 rajveer 14986 
          (_etype276, _size273) = iprot.readListBegin()
14987 
          for _i277 in xrange(_size273):
14988 
            _elem278 = iprot.readString();
14989 
            self.itemNumber.append(_elem278)
5411 rajveer 14990 
          iprot.readListEnd()
3064 chandransh 14991 
        else:
14992 
          iprot.skip(ftype)
14993 
      elif fid == 5:
7190 amar.kumar 14994 
        if ftype == TType.I64:
14995 
          self.freebieWarehouseId = iprot.readI64();
14996 
        else:
14997 
          iprot.skip(ftype)
14998 
      elif fid == 6:
3064 chandransh 14999 
        if ftype == TType.STRING:
4283 anupam.sin 15000 
          self.billed_by = iprot.readString();
3064 chandransh 15001 
        else:
15002 
          iprot.skip(ftype)
7190 amar.kumar 15003 
      elif fid == 7:
3064 chandransh 15004 
        if ftype == TType.I64:
4283 anupam.sin 15005 
          self.jacketNumber = iprot.readI64();
15006 
        else:
15007 
          iprot.skip(ftype)
7190 amar.kumar 15008 
      elif fid == 8:
4283 anupam.sin 15009 
        if ftype == TType.I64:
3064 chandransh 15010 
          self.billingType = iprot.readI64();
15011 
        else:
15012 
          iprot.skip(ftype)
7190 amar.kumar 15013 
      elif fid == 9:
4283 anupam.sin 15014 
        if ftype == TType.I64:
5110 mandeep.dh 15015 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 15016 
        else:
15017 
          iprot.skip(ftype)
7190 amar.kumar 15018 
      elif fid == 10:
4763 rajveer 15019 
        if ftype == TType.BOOL:
15020 
          self.authorize = iprot.readBool();
15021 
        else:
15022 
          iprot.skip(ftype)
1246 chandransh 15023 
      else:
15024 
        iprot.skip(ftype)
15025 
      iprot.readFieldEnd()
15026 
    iprot.readStructEnd()
15027 
 
15028 
  def write(self, oprot):
15029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15031 
      return
4283 anupam.sin 15032 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 15033 
    if self.orderId is not None:
3064 chandransh 15034 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15035 
      oprot.writeI64(self.orderId)
1246 chandransh 15036 
      oprot.writeFieldEnd()
4283 anupam.sin 15037 
    if self.invoice_number is not None:
15038 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
15039 
      oprot.writeString(self.invoice_number)
1246 chandransh 15040 
      oprot.writeFieldEnd()
4658 mandeep.dh 15041 
    if self.serialNumber is not None:
5411 rajveer 15042 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
15043 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 15044 
      for iter279 in self.serialNumber:
15045 
        oprot.writeString(iter279)
5411 rajveer 15046 
      oprot.writeListEnd()
3064 chandransh 15047 
      oprot.writeFieldEnd()
3431 rajveer 15048 
    if self.itemNumber is not None:
5411 rajveer 15049 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
15050 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 15051 
      for iter280 in self.itemNumber:
15052 
        oprot.writeString(iter280)
5411 rajveer 15053 
      oprot.writeListEnd()
3064 chandransh 15054 
      oprot.writeFieldEnd()
7190 amar.kumar 15055 
    if self.freebieWarehouseId is not None:
15056 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 5)
15057 
      oprot.writeI64(self.freebieWarehouseId)
15058 
      oprot.writeFieldEnd()
4283 anupam.sin 15059 
    if self.billed_by is not None:
7190 amar.kumar 15060 
      oprot.writeFieldBegin('billed_by', TType.STRING, 6)
4283 anupam.sin 15061 
      oprot.writeString(self.billed_by)
3064 chandransh 15062 
      oprot.writeFieldEnd()
4283 anupam.sin 15063 
    if self.jacketNumber is not None:
7190 amar.kumar 15064 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 7)
4283 anupam.sin 15065 
      oprot.writeI64(self.jacketNumber)
15066 
      oprot.writeFieldEnd()
3431 rajveer 15067 
    if self.billingType is not None:
7190 amar.kumar 15068 
      oprot.writeFieldBegin('billingType', TType.I64, 8)
3064 chandransh 15069 
      oprot.writeI64(self.billingType)
15070 
      oprot.writeFieldEnd()
5110 mandeep.dh 15071 
    if self.fulfilmentWarehouseId is not None:
7190 amar.kumar 15072 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 9)
5110 mandeep.dh 15073 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 15074 
      oprot.writeFieldEnd()
4763 rajveer 15075 
    if self.authorize is not None:
7190 amar.kumar 15076 
      oprot.writeFieldBegin('authorize', TType.BOOL, 10)
4763 rajveer 15077 
      oprot.writeBool(self.authorize)
15078 
      oprot.writeFieldEnd()
1246 chandransh 15079 
    oprot.writeFieldStop()
15080 
    oprot.writeStructEnd()
15081 
 
3431 rajveer 15082 
  def validate(self):
15083 
    return
15084 
 
15085 
 
1246 chandransh 15086 
  def __repr__(self):
15087 
    L = ['%s=%r' % (key, value)
15088 
      for key, value in self.__dict__.iteritems()]
15089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15090 
 
15091 
  def __eq__(self, other):
15092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15093 
 
15094 
  def __ne__(self, other):
15095 
    return not (self == other)
15096 
 
4283 anupam.sin 15097 
class addBillingDetails_result:
1246 chandransh 15098 
  """
15099 
  Attributes:
3064 chandransh 15100 
   - success
1246 chandransh 15101 
   - ex
15102 
  """
15103 
 
15104 
  thrift_spec = (
3064 chandransh 15105 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 15106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15107 
  )
15108 
 
3064 chandransh 15109 
  def __init__(self, success=None, ex=None,):
15110 
    self.success = success
1246 chandransh 15111 
    self.ex = ex
15112 
 
15113 
  def read(self, iprot):
15114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15116 
      return
15117 
    iprot.readStructBegin()
15118 
    while True:
15119 
      (fname, ftype, fid) = iprot.readFieldBegin()
15120 
      if ftype == TType.STOP:
15121 
        break
3064 chandransh 15122 
      if fid == 0:
15123 
        if ftype == TType.BOOL:
15124 
          self.success = iprot.readBool();
15125 
        else:
15126 
          iprot.skip(ftype)
15127 
      elif fid == 1:
1246 chandransh 15128 
        if ftype == TType.STRUCT:
15129 
          self.ex = TransactionServiceException()
15130 
          self.ex.read(iprot)
15131 
        else:
15132 
          iprot.skip(ftype)
15133 
      else:
15134 
        iprot.skip(ftype)
15135 
      iprot.readFieldEnd()
15136 
    iprot.readStructEnd()
15137 
 
15138 
  def write(self, oprot):
15139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15141 
      return
4283 anupam.sin 15142 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 15143 
    if self.success is not None:
3064 chandransh 15144 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15145 
      oprot.writeBool(self.success)
15146 
      oprot.writeFieldEnd()
3431 rajveer 15147 
    if self.ex is not None:
1246 chandransh 15148 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15149 
      self.ex.write(oprot)
15150 
      oprot.writeFieldEnd()
15151 
    oprot.writeFieldStop()
15152 
    oprot.writeStructEnd()
15153 
 
3431 rajveer 15154 
  def validate(self):
15155 
    return
15156 
 
15157 
 
1246 chandransh 15158 
  def __repr__(self):
15159 
    L = ['%s=%r' % (key, value)
15160 
      for key, value in self.__dict__.iteritems()]
15161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15162 
 
15163 
  def __eq__(self, other):
15164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15165 
 
15166 
  def __ne__(self, other):
15167 
    return not (self == other)
15168 
 
4579 rajveer 15169 
class addInvoiceNumber_args:
15170 
  """
15171 
  Attributes:
15172 
   - orderId
15173 
   - invoiceNumber
4763 rajveer 15174 
   - color
6756 amar.kumar 15175 
   - serialNumber
15176 
   - itemNumber
4579 rajveer 15177 
  """
15178 
 
15179 
  thrift_spec = (
15180 
    None, # 0
15181 
    (1, TType.I64, 'orderId', None, None, ), # 1
15182 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 15183 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 15184 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
15185 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 15186 
  )
15187 
 
6756 amar.kumar 15188 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 15189 
    self.orderId = orderId
15190 
    self.invoiceNumber = invoiceNumber
4763 rajveer 15191 
    self.color = color
6756 amar.kumar 15192 
    self.serialNumber = serialNumber
15193 
    self.itemNumber = itemNumber
4579 rajveer 15194 
 
15195 
  def read(self, iprot):
15196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15198 
      return
15199 
    iprot.readStructBegin()
15200 
    while True:
15201 
      (fname, ftype, fid) = iprot.readFieldBegin()
15202 
      if ftype == TType.STOP:
15203 
        break
15204 
      if fid == 1:
15205 
        if ftype == TType.I64:
15206 
          self.orderId = iprot.readI64();
15207 
        else:
15208 
          iprot.skip(ftype)
15209 
      elif fid == 2:
15210 
        if ftype == TType.STRING:
15211 
          self.invoiceNumber = iprot.readString();
15212 
        else:
15213 
          iprot.skip(ftype)
4763 rajveer 15214 
      elif fid == 3:
15215 
        if ftype == TType.STRING:
15216 
          self.color = iprot.readString();
15217 
        else:
15218 
          iprot.skip(ftype)
6756 amar.kumar 15219 
      elif fid == 4:
15220 
        if ftype == TType.STRING:
15221 
          self.serialNumber = iprot.readString();
15222 
        else:
15223 
          iprot.skip(ftype)
15224 
      elif fid == 5:
15225 
        if ftype == TType.STRING:
15226 
          self.itemNumber = iprot.readString();
15227 
        else:
15228 
          iprot.skip(ftype)
4579 rajveer 15229 
      else:
15230 
        iprot.skip(ftype)
15231 
      iprot.readFieldEnd()
15232 
    iprot.readStructEnd()
15233 
 
15234 
  def write(self, oprot):
15235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15237 
      return
15238 
    oprot.writeStructBegin('addInvoiceNumber_args')
15239 
    if self.orderId is not None:
15240 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15241 
      oprot.writeI64(self.orderId)
15242 
      oprot.writeFieldEnd()
15243 
    if self.invoiceNumber is not None:
15244 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
15245 
      oprot.writeString(self.invoiceNumber)
15246 
      oprot.writeFieldEnd()
4763 rajveer 15247 
    if self.color is not None:
15248 
      oprot.writeFieldBegin('color', TType.STRING, 3)
15249 
      oprot.writeString(self.color)
15250 
      oprot.writeFieldEnd()
6756 amar.kumar 15251 
    if self.serialNumber is not None:
15252 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
15253 
      oprot.writeString(self.serialNumber)
15254 
      oprot.writeFieldEnd()
15255 
    if self.itemNumber is not None:
15256 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
15257 
      oprot.writeString(self.itemNumber)
15258 
      oprot.writeFieldEnd()
4579 rajveer 15259 
    oprot.writeFieldStop()
15260 
    oprot.writeStructEnd()
15261 
 
15262 
  def validate(self):
15263 
    return
15264 
 
15265 
 
15266 
  def __repr__(self):
15267 
    L = ['%s=%r' % (key, value)
15268 
      for key, value in self.__dict__.iteritems()]
15269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15270 
 
15271 
  def __eq__(self, other):
15272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15273 
 
15274 
  def __ne__(self, other):
15275 
    return not (self == other)
15276 
 
15277 
class addInvoiceNumber_result:
15278 
  """
15279 
  Attributes:
15280 
   - ex
15281 
  """
15282 
 
15283 
  thrift_spec = (
15284 
    None, # 0
15285 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15286 
  )
15287 
 
15288 
  def __init__(self, ex=None,):
15289 
    self.ex = ex
15290 
 
15291 
  def read(self, iprot):
15292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15294 
      return
15295 
    iprot.readStructBegin()
15296 
    while True:
15297 
      (fname, ftype, fid) = iprot.readFieldBegin()
15298 
      if ftype == TType.STOP:
15299 
        break
15300 
      if fid == 1:
15301 
        if ftype == TType.STRUCT:
15302 
          self.ex = TransactionServiceException()
15303 
          self.ex.read(iprot)
15304 
        else:
15305 
          iprot.skip(ftype)
15306 
      else:
15307 
        iprot.skip(ftype)
15308 
      iprot.readFieldEnd()
15309 
    iprot.readStructEnd()
15310 
 
15311 
  def write(self, oprot):
15312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15314 
      return
15315 
    oprot.writeStructBegin('addInvoiceNumber_result')
15316 
    if self.ex is not None:
15317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15318 
      self.ex.write(oprot)
15319 
      oprot.writeFieldEnd()
15320 
    oprot.writeFieldStop()
15321 
    oprot.writeStructEnd()
15322 
 
15323 
  def validate(self):
15324 
    return
15325 
 
15326 
 
15327 
  def __repr__(self):
15328 
    L = ['%s=%r' % (key, value)
15329 
      for key, value in self.__dict__.iteritems()]
15330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15331 
 
15332 
  def __eq__(self, other):
15333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15334 
 
15335 
  def __ne__(self, other):
15336 
    return not (self == other)
15337 
 
4910 phani.kuma 15338 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 15339 
  """
15340 
  Attributes:
3064 chandransh 15341 
   - warehouseId
1408 ankur.sing 15342 
   - providerId
3064 chandransh 15343 
   - cod
4910 phani.kuma 15344 
   - orderIds
1408 ankur.sing 15345 
  """
15346 
 
15347 
  thrift_spec = (
15348 
    None, # 0
3064 chandransh 15349 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15350 
    (2, TType.I64, 'providerId', None, None, ), # 2
15351 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 15352 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 15353 
  )
15354 
 
4910 phani.kuma 15355 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 15356 
    self.warehouseId = warehouseId
1408 ankur.sing 15357 
    self.providerId = providerId
3064 chandransh 15358 
    self.cod = cod
4910 phani.kuma 15359 
    self.orderIds = orderIds
1408 ankur.sing 15360 
 
15361 
  def read(self, iprot):
15362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15364 
      return
15365 
    iprot.readStructBegin()
15366 
    while True:
15367 
      (fname, ftype, fid) = iprot.readFieldBegin()
15368 
      if ftype == TType.STOP:
15369 
        break
15370 
      if fid == 1:
15371 
        if ftype == TType.I64:
3064 chandransh 15372 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 15373 
        else:
15374 
          iprot.skip(ftype)
15375 
      elif fid == 2:
15376 
        if ftype == TType.I64:
3064 chandransh 15377 
          self.providerId = iprot.readI64();
1408 ankur.sing 15378 
        else:
15379 
          iprot.skip(ftype)
3064 chandransh 15380 
      elif fid == 3:
15381 
        if ftype == TType.BOOL:
15382 
          self.cod = iprot.readBool();
15383 
        else:
15384 
          iprot.skip(ftype)
4910 phani.kuma 15385 
      elif fid == 4:
15386 
        if ftype == TType.LIST:
15387 
          self.orderIds = []
6188 rajveer 15388 
          (_etype284, _size281) = iprot.readListBegin()
15389 
          for _i285 in xrange(_size281):
15390 
            _elem286 = iprot.readI64();
15391 
            self.orderIds.append(_elem286)
4910 phani.kuma 15392 
          iprot.readListEnd()
15393 
        else:
15394 
          iprot.skip(ftype)
1408 ankur.sing 15395 
      else:
15396 
        iprot.skip(ftype)
15397 
      iprot.readFieldEnd()
15398 
    iprot.readStructEnd()
15399 
 
15400 
  def write(self, oprot):
15401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15403 
      return
4910 phani.kuma 15404 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 15405 
    if self.warehouseId is not None:
3064 chandransh 15406 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
15407 
      oprot.writeI64(self.warehouseId)
15408 
      oprot.writeFieldEnd()
3431 rajveer 15409 
    if self.providerId is not None:
3064 chandransh 15410 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 15411 
      oprot.writeI64(self.providerId)
15412 
      oprot.writeFieldEnd()
3431 rajveer 15413 
    if self.cod is not None:
3064 chandransh 15414 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
15415 
      oprot.writeBool(self.cod)
1408 ankur.sing 15416 
      oprot.writeFieldEnd()
4910 phani.kuma 15417 
    if self.orderIds is not None:
15418 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
15419 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15420 
      for iter287 in self.orderIds:
15421 
        oprot.writeI64(iter287)
4910 phani.kuma 15422 
      oprot.writeListEnd()
15423 
      oprot.writeFieldEnd()
1408 ankur.sing 15424 
    oprot.writeFieldStop()
15425 
    oprot.writeStructEnd()
15426 
 
3431 rajveer 15427 
  def validate(self):
15428 
    return
15429 
 
15430 
 
1408 ankur.sing 15431 
  def __repr__(self):
15432 
    L = ['%s=%r' % (key, value)
15433 
      for key, value in self.__dict__.iteritems()]
15434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15435 
 
15436 
  def __eq__(self, other):
15437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15438 
 
15439 
  def __ne__(self, other):
15440 
    return not (self == other)
15441 
 
4910 phani.kuma 15442 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 15443 
  """
15444 
  Attributes:
15445 
   - success
3064 chandransh 15446 
   - ex
1408 ankur.sing 15447 
  """
15448 
 
15449 
  thrift_spec = (
3064 chandransh 15450 
    (0, TType.BOOL, 'success', None, None, ), # 0
15451 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 15452 
  )
15453 
 
3064 chandransh 15454 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 15455 
    self.success = success
3064 chandransh 15456 
    self.ex = ex
1408 ankur.sing 15457 
 
15458 
  def read(self, iprot):
15459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15461 
      return
15462 
    iprot.readStructBegin()
15463 
    while True:
15464 
      (fname, ftype, fid) = iprot.readFieldBegin()
15465 
      if ftype == TType.STOP:
15466 
        break
15467 
      if fid == 0:
3064 chandransh 15468 
        if ftype == TType.BOOL:
15469 
          self.success = iprot.readBool();
1408 ankur.sing 15470 
        else:
15471 
          iprot.skip(ftype)
3064 chandransh 15472 
      elif fid == 1:
15473 
        if ftype == TType.STRUCT:
15474 
          self.ex = TransactionServiceException()
15475 
          self.ex.read(iprot)
15476 
        else:
15477 
          iprot.skip(ftype)
1408 ankur.sing 15478 
      else:
15479 
        iprot.skip(ftype)
15480 
      iprot.readFieldEnd()
15481 
    iprot.readStructEnd()
15482 
 
15483 
  def write(self, oprot):
15484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15486 
      return
4910 phani.kuma 15487 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 15488 
    if self.success is not None:
3064 chandransh 15489 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15490 
      oprot.writeBool(self.success)
1408 ankur.sing 15491 
      oprot.writeFieldEnd()
3431 rajveer 15492 
    if self.ex is not None:
3064 chandransh 15493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15494 
      self.ex.write(oprot)
15495 
      oprot.writeFieldEnd()
1408 ankur.sing 15496 
    oprot.writeFieldStop()
15497 
    oprot.writeStructEnd()
15498 
 
3431 rajveer 15499 
  def validate(self):
15500 
    return
15501 
 
15502 
 
1408 ankur.sing 15503 
  def __repr__(self):
15504 
    L = ['%s=%r' % (key, value)
15505 
      for key, value in self.__dict__.iteritems()]
15506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15507 
 
15508 
  def __eq__(self, other):
15509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15510 
 
15511 
  def __ne__(self, other):
15512 
    return not (self == other)
15513 
 
5676 rajveer 15514 
class markOrdersAsReturnedFromStore_args:
15515 
  """
15516 
  Attributes:
15517 
   - providerId
15518 
   - orderIds
5713 rajveer 15519 
   - awbs
5676 rajveer 15520 
  """
15521 
 
15522 
  thrift_spec = (
15523 
    None, # 0
15524 
    (1, TType.I64, 'providerId', None, None, ), # 1
15525 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 15526 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 15527 
  )
15528 
 
5713 rajveer 15529 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 15530 
    self.providerId = providerId
15531 
    self.orderIds = orderIds
5713 rajveer 15532 
    self.awbs = awbs
5676 rajveer 15533 
 
15534 
  def read(self, iprot):
15535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15537 
      return
15538 
    iprot.readStructBegin()
15539 
    while True:
15540 
      (fname, ftype, fid) = iprot.readFieldBegin()
15541 
      if ftype == TType.STOP:
15542 
        break
15543 
      if fid == 1:
15544 
        if ftype == TType.I64:
15545 
          self.providerId = iprot.readI64();
15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      elif fid == 2:
15549 
        if ftype == TType.LIST:
15550 
          self.orderIds = []
6188 rajveer 15551 
          (_etype291, _size288) = iprot.readListBegin()
15552 
          for _i292 in xrange(_size288):
15553 
            _elem293 = iprot.readI64();
15554 
            self.orderIds.append(_elem293)
5676 rajveer 15555 
          iprot.readListEnd()
15556 
        else:
15557 
          iprot.skip(ftype)
5713 rajveer 15558 
      elif fid == 3:
15559 
        if ftype == TType.LIST:
15560 
          self.awbs = []
6188 rajveer 15561 
          (_etype297, _size294) = iprot.readListBegin()
15562 
          for _i298 in xrange(_size294):
15563 
            _elem299 = iprot.readString();
15564 
            self.awbs.append(_elem299)
5713 rajveer 15565 
          iprot.readListEnd()
15566 
        else:
15567 
          iprot.skip(ftype)
5676 rajveer 15568 
      else:
15569 
        iprot.skip(ftype)
15570 
      iprot.readFieldEnd()
15571 
    iprot.readStructEnd()
15572 
 
15573 
  def write(self, oprot):
15574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15576 
      return
15577 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
15578 
    if self.providerId is not None:
15579 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15580 
      oprot.writeI64(self.providerId)
15581 
      oprot.writeFieldEnd()
15582 
    if self.orderIds is not None:
15583 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
15584 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15585 
      for iter300 in self.orderIds:
15586 
        oprot.writeI64(iter300)
5676 rajveer 15587 
      oprot.writeListEnd()
15588 
      oprot.writeFieldEnd()
5713 rajveer 15589 
    if self.awbs is not None:
15590 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
15591 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 15592 
      for iter301 in self.awbs:
15593 
        oprot.writeString(iter301)
5713 rajveer 15594 
      oprot.writeListEnd()
15595 
      oprot.writeFieldEnd()
5676 rajveer 15596 
    oprot.writeFieldStop()
15597 
    oprot.writeStructEnd()
15598 
 
15599 
  def validate(self):
15600 
    return
15601 
 
15602 
 
15603 
  def __repr__(self):
15604 
    L = ['%s=%r' % (key, value)
15605 
      for key, value in self.__dict__.iteritems()]
15606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15607 
 
15608 
  def __eq__(self, other):
15609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15610 
 
15611 
  def __ne__(self, other):
15612 
    return not (self == other)
15613 
 
15614 
class markOrdersAsReturnedFromStore_result:
15615 
  """
15616 
  Attributes:
15617 
   - success
15618 
   - ex
15619 
  """
15620 
 
15621 
  thrift_spec = (
15622 
    (0, TType.BOOL, 'success', None, None, ), # 0
15623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15624 
  )
15625 
 
15626 
  def __init__(self, success=None, ex=None,):
15627 
    self.success = success
15628 
    self.ex = ex
15629 
 
15630 
  def read(self, iprot):
15631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15633 
      return
15634 
    iprot.readStructBegin()
15635 
    while True:
15636 
      (fname, ftype, fid) = iprot.readFieldBegin()
15637 
      if ftype == TType.STOP:
15638 
        break
15639 
      if fid == 0:
15640 
        if ftype == TType.BOOL:
15641 
          self.success = iprot.readBool();
15642 
        else:
15643 
          iprot.skip(ftype)
15644 
      elif fid == 1:
15645 
        if ftype == TType.STRUCT:
15646 
          self.ex = TransactionServiceException()
15647 
          self.ex.read(iprot)
15648 
        else:
15649 
          iprot.skip(ftype)
15650 
      else:
15651 
        iprot.skip(ftype)
15652 
      iprot.readFieldEnd()
15653 
    iprot.readStructEnd()
15654 
 
15655 
  def write(self, oprot):
15656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15658 
      return
15659 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
15660 
    if self.success is not None:
15661 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15662 
      oprot.writeBool(self.success)
15663 
      oprot.writeFieldEnd()
15664 
    if self.ex is not None:
15665 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15666 
      self.ex.write(oprot)
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 
 
4910 phani.kuma 15686 
class markOrdersAsPickedUp_args:
4410 rajveer 15687 
  """
15688 
  Attributes:
15689 
   - providerId
4910 phani.kuma 15690 
   - pickupDetails
4410 rajveer 15691 
  """
15692 
 
15693 
  thrift_spec = (
15694 
    None, # 0
4910 phani.kuma 15695 
    (1, TType.I64, 'providerId', None, None, ), # 1
15696 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15697 
  )
15698 
 
4910 phani.kuma 15699 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15700 
    self.providerId = providerId
4910 phani.kuma 15701 
    self.pickupDetails = pickupDetails
4410 rajveer 15702 
 
15703 
  def read(self, iprot):
15704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15706 
      return
15707 
    iprot.readStructBegin()
15708 
    while True:
15709 
      (fname, ftype, fid) = iprot.readFieldBegin()
15710 
      if ftype == TType.STOP:
15711 
        break
15712 
      if fid == 1:
15713 
        if ftype == TType.I64:
4910 phani.kuma 15714 
          self.providerId = iprot.readI64();
4410 rajveer 15715 
        else:
15716 
          iprot.skip(ftype)
15717 
      elif fid == 2:
4910 phani.kuma 15718 
        if ftype == TType.MAP:
15719 
          self.pickupDetails = {}
6188 rajveer 15720 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15721 
          for _i306 in xrange(_size302):
15722 
            _key307 = iprot.readString();
15723 
            _val308 = iprot.readString();
15724 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15725 
          iprot.readMapEnd()
4410 rajveer 15726 
        else:
15727 
          iprot.skip(ftype)
15728 
      else:
15729 
        iprot.skip(ftype)
15730 
      iprot.readFieldEnd()
15731 
    iprot.readStructEnd()
15732 
 
15733 
  def write(self, oprot):
15734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15736 
      return
4910 phani.kuma 15737 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15738 
    if self.providerId is not None:
4910 phani.kuma 15739 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15740 
      oprot.writeI64(self.providerId)
15741 
      oprot.writeFieldEnd()
4910 phani.kuma 15742 
    if self.pickupDetails is not None:
15743 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15744 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15745 
      for kiter309,viter310 in self.pickupDetails.items():
15746 
        oprot.writeString(kiter309)
15747 
        oprot.writeString(viter310)
4910 phani.kuma 15748 
      oprot.writeMapEnd()
4410 rajveer 15749 
      oprot.writeFieldEnd()
15750 
    oprot.writeFieldStop()
15751 
    oprot.writeStructEnd()
15752 
 
15753 
  def validate(self):
15754 
    return
15755 
 
15756 
 
15757 
  def __repr__(self):
15758 
    L = ['%s=%r' % (key, value)
15759 
      for key, value in self.__dict__.iteritems()]
15760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15761 
 
15762 
  def __eq__(self, other):
15763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15764 
 
15765 
  def __ne__(self, other):
15766 
    return not (self == other)
15767 
 
4910 phani.kuma 15768 
class markOrdersAsPickedUp_result:
4410 rajveer 15769 
  """
15770 
  Attributes:
15771 
   - ex
15772 
  """
15773 
 
15774 
  thrift_spec = (
4910 phani.kuma 15775 
    None, # 0
4410 rajveer 15776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15777 
  )
15778 
 
4910 phani.kuma 15779 
  def __init__(self, ex=None,):
4410 rajveer 15780 
    self.ex = ex
15781 
 
15782 
  def read(self, iprot):
15783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15785 
      return
15786 
    iprot.readStructBegin()
15787 
    while True:
15788 
      (fname, ftype, fid) = iprot.readFieldBegin()
15789 
      if ftype == TType.STOP:
15790 
        break
4910 phani.kuma 15791 
      if fid == 1:
4410 rajveer 15792 
        if ftype == TType.STRUCT:
15793 
          self.ex = TransactionServiceException()
15794 
          self.ex.read(iprot)
15795 
        else:
15796 
          iprot.skip(ftype)
15797 
      else:
15798 
        iprot.skip(ftype)
15799 
      iprot.readFieldEnd()
15800 
    iprot.readStructEnd()
15801 
 
15802 
  def write(self, oprot):
15803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15805 
      return
4910 phani.kuma 15806 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15807 
    if self.ex is not None:
15808 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15809 
      self.ex.write(oprot)
15810 
      oprot.writeFieldEnd()
15811 
    oprot.writeFieldStop()
15812 
    oprot.writeStructEnd()
15813 
 
15814 
  def validate(self):
15815 
    return
15816 
 
15817 
 
15818 
  def __repr__(self):
15819 
    L = ['%s=%r' % (key, value)
15820 
      for key, value in self.__dict__.iteritems()]
15821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15822 
 
15823 
  def __eq__(self, other):
15824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15825 
 
15826 
  def __ne__(self, other):
15827 
    return not (self == other)
15828 
 
4910 phani.kuma 15829 
class getOrdersNotPickedUp_args:
304 ashish 15830 
  """
15831 
  Attributes:
3064 chandransh 15832 
   - providerId
304 ashish 15833 
  """
94 ashish 15834 
 
304 ashish 15835 
  thrift_spec = (
15836 
    None, # 0
3064 chandransh 15837 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15838 
  )
15839 
 
4910 phani.kuma 15840 
  def __init__(self, providerId=None,):
3064 chandransh 15841 
    self.providerId = providerId
304 ashish 15842 
 
15843 
  def read(self, iprot):
15844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15846 
      return
15847 
    iprot.readStructBegin()
15848 
    while True:
15849 
      (fname, ftype, fid) = iprot.readFieldBegin()
15850 
      if ftype == TType.STOP:
15851 
        break
15852 
      if fid == 1:
15853 
        if ftype == TType.I64:
3064 chandransh 15854 
          self.providerId = iprot.readI64();
304 ashish 15855 
        else:
15856 
          iprot.skip(ftype)
15857 
      else:
15858 
        iprot.skip(ftype)
15859 
      iprot.readFieldEnd()
15860 
    iprot.readStructEnd()
15861 
 
15862 
  def write(self, oprot):
15863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15865 
      return
4910 phani.kuma 15866 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15867 
    if self.providerId is not None:
3064 chandransh 15868 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15869 
      oprot.writeI64(self.providerId)
304 ashish 15870 
      oprot.writeFieldEnd()
15871 
    oprot.writeFieldStop()
15872 
    oprot.writeStructEnd()
15873 
 
3431 rajveer 15874 
  def validate(self):
15875 
    return
15876 
 
15877 
 
304 ashish 15878 
  def __repr__(self):
15879 
    L = ['%s=%r' % (key, value)
15880 
      for key, value in self.__dict__.iteritems()]
15881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15882 
 
15883 
  def __eq__(self, other):
15884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15885 
 
15886 
  def __ne__(self, other):
15887 
    return not (self == other)
15888 
 
4910 phani.kuma 15889 
class getOrdersNotPickedUp_result:
304 ashish 15890 
  """
15891 
  Attributes:
15892 
   - success
15893 
  """
15894 
 
15895 
  thrift_spec = (
3064 chandransh 15896 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15897 
  )
15898 
 
4910 phani.kuma 15899 
  def __init__(self, success=None,):
304 ashish 15900 
    self.success = success
15901 
 
15902 
  def read(self, iprot):
15903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15905 
      return
15906 
    iprot.readStructBegin()
15907 
    while True:
15908 
      (fname, ftype, fid) = iprot.readFieldBegin()
15909 
      if ftype == TType.STOP:
15910 
        break
15911 
      if fid == 0:
15912 
        if ftype == TType.LIST:
15913 
          self.success = []
6188 rajveer 15914 
          (_etype314, _size311) = iprot.readListBegin()
15915 
          for _i315 in xrange(_size311):
15916 
            _elem316 = Order()
15917 
            _elem316.read(iprot)
15918 
            self.success.append(_elem316)
304 ashish 15919 
          iprot.readListEnd()
15920 
        else:
15921 
          iprot.skip(ftype)
15922 
      else:
15923 
        iprot.skip(ftype)
15924 
      iprot.readFieldEnd()
15925 
    iprot.readStructEnd()
15926 
 
15927 
  def write(self, oprot):
15928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15930 
      return
4910 phani.kuma 15931 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15932 
    if self.success is not None:
304 ashish 15933 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15934 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15935 
      for iter317 in self.success:
15936 
        iter317.write(oprot)
304 ashish 15937 
      oprot.writeListEnd()
15938 
      oprot.writeFieldEnd()
15939 
    oprot.writeFieldStop()
15940 
    oprot.writeStructEnd()
15941 
 
3431 rajveer 15942 
  def validate(self):
15943 
    return
15944 
 
15945 
 
304 ashish 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 
 
3064 chandransh 15957 
class markOrdersAsDelivered_args:
304 ashish 15958 
  """
15959 
  Attributes:
3064 chandransh 15960 
   - providerId
15961 
   - deliveredOrders
304 ashish 15962 
  """
15963 
 
15964 
  thrift_spec = (
15965 
    None, # 0
3064 chandransh 15966 
    (1, TType.I64, 'providerId', None, None, ), # 1
15967 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15968 
  )
15969 
 
3064 chandransh 15970 
  def __init__(self, providerId=None, deliveredOrders=None,):
15971 
    self.providerId = providerId
15972 
    self.deliveredOrders = deliveredOrders
304 ashish 15973 
 
15974 
  def read(self, iprot):
15975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15977 
      return
15978 
    iprot.readStructBegin()
15979 
    while True:
15980 
      (fname, ftype, fid) = iprot.readFieldBegin()
15981 
      if ftype == TType.STOP:
15982 
        break
15983 
      if fid == 1:
15984 
        if ftype == TType.I64:
3064 chandransh 15985 
          self.providerId = iprot.readI64();
304 ashish 15986 
        else:
15987 
          iprot.skip(ftype)
15988 
      elif fid == 2:
3064 chandransh 15989 
        if ftype == TType.MAP:
15990 
          self.deliveredOrders = {}
6188 rajveer 15991 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15992 
          for _i322 in xrange(_size318):
15993 
            _key323 = iprot.readString();
15994 
            _val324 = iprot.readString();
15995 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15996 
          iprot.readMapEnd()
304 ashish 15997 
        else:
15998 
          iprot.skip(ftype)
15999 
      else:
16000 
        iprot.skip(ftype)
16001 
      iprot.readFieldEnd()
16002 
    iprot.readStructEnd()
16003 
 
16004 
  def write(self, oprot):
16005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16007 
      return
3064 chandransh 16008 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 16009 
    if self.providerId is not None:
3064 chandransh 16010 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16011 
      oprot.writeI64(self.providerId)
304 ashish 16012 
      oprot.writeFieldEnd()
3431 rajveer 16013 
    if self.deliveredOrders is not None:
3064 chandransh 16014 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
16015 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 16016 
      for kiter325,viter326 in self.deliveredOrders.items():
16017 
        oprot.writeString(kiter325)
16018 
        oprot.writeString(viter326)
3064 chandransh 16019 
      oprot.writeMapEnd()
304 ashish 16020 
      oprot.writeFieldEnd()
16021 
    oprot.writeFieldStop()
16022 
    oprot.writeStructEnd()
16023 
 
3431 rajveer 16024 
  def validate(self):
16025 
    return
16026 
 
16027 
 
304 ashish 16028 
  def __repr__(self):
16029 
    L = ['%s=%r' % (key, value)
16030 
      for key, value in self.__dict__.iteritems()]
16031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16032 
 
16033 
  def __eq__(self, other):
16034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16035 
 
16036 
  def __ne__(self, other):
16037 
    return not (self == other)
16038 
 
3064 chandransh 16039 
class markOrdersAsDelivered_result:
16040 
  """
16041 
  Attributes:
16042 
   - ex
16043 
  """
304 ashish 16044 
 
16045 
  thrift_spec = (
3064 chandransh 16046 
    None, # 0
16047 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 16048 
  )
16049 
 
3064 chandransh 16050 
  def __init__(self, ex=None,):
16051 
    self.ex = ex
304 ashish 16052 
 
1596 ankur.sing 16053 
  def read(self, iprot):
16054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16056 
      return
16057 
    iprot.readStructBegin()
16058 
    while True:
16059 
      (fname, ftype, fid) = iprot.readFieldBegin()
16060 
      if ftype == TType.STOP:
16061 
        break
3064 chandransh 16062 
      if fid == 1:
16063 
        if ftype == TType.STRUCT:
16064 
          self.ex = TransactionServiceException()
16065 
          self.ex.read(iprot)
16066 
        else:
16067 
          iprot.skip(ftype)
1596 ankur.sing 16068 
      else:
16069 
        iprot.skip(ftype)
16070 
      iprot.readFieldEnd()
16071 
    iprot.readStructEnd()
16072 
 
16073 
  def write(self, oprot):
16074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16076 
      return
3064 chandransh 16077 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 16078 
    if self.ex is not None:
3064 chandransh 16079 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16080 
      self.ex.write(oprot)
16081 
      oprot.writeFieldEnd()
1596 ankur.sing 16082 
    oprot.writeFieldStop()
16083 
    oprot.writeStructEnd()
16084 
 
3431 rajveer 16085 
  def validate(self):
16086 
    return
16087 
 
16088 
 
1596 ankur.sing 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 
 
4910 phani.kuma 16100 
class markAsRTOrders_args:
1596 ankur.sing 16101 
  """
16102 
  Attributes:
3064 chandransh 16103 
   - providerId
16104 
   - returnedOrders
1596 ankur.sing 16105 
  """
16106 
 
16107 
  thrift_spec = (
3064 chandransh 16108 
    None, # 0
16109 
    (1, TType.I64, 'providerId', None, None, ), # 1
16110 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 16111 
  )
16112 
 
3064 chandransh 16113 
  def __init__(self, providerId=None, returnedOrders=None,):
16114 
    self.providerId = providerId
16115 
    self.returnedOrders = returnedOrders
1596 ankur.sing 16116 
 
16117 
  def read(self, iprot):
16118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16120 
      return
16121 
    iprot.readStructBegin()
16122 
    while True:
16123 
      (fname, ftype, fid) = iprot.readFieldBegin()
16124 
      if ftype == TType.STOP:
16125 
        break
3064 chandransh 16126 
      if fid == 1:
1596 ankur.sing 16127 
        if ftype == TType.I64:
3064 chandransh 16128 
          self.providerId = iprot.readI64();
1596 ankur.sing 16129 
        else:
16130 
          iprot.skip(ftype)
3064 chandransh 16131 
      elif fid == 2:
16132 
        if ftype == TType.MAP:
16133 
          self.returnedOrders = {}
6188 rajveer 16134 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
16135 
          for _i331 in xrange(_size327):
16136 
            _key332 = iprot.readString();
16137 
            _val333 = iprot.readString();
16138 
            self.returnedOrders[_key332] = _val333
3064 chandransh 16139 
          iprot.readMapEnd()
16140 
        else:
16141 
          iprot.skip(ftype)
1596 ankur.sing 16142 
      else:
16143 
        iprot.skip(ftype)
16144 
      iprot.readFieldEnd()
16145 
    iprot.readStructEnd()
16146 
 
16147 
  def write(self, oprot):
16148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16150 
      return
4910 phani.kuma 16151 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 16152 
    if self.providerId is not None:
3064 chandransh 16153 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16154 
      oprot.writeI64(self.providerId)
1596 ankur.sing 16155 
      oprot.writeFieldEnd()
3431 rajveer 16156 
    if self.returnedOrders is not None:
3064 chandransh 16157 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
16158 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 16159 
      for kiter334,viter335 in self.returnedOrders.items():
16160 
        oprot.writeString(kiter334)
16161 
        oprot.writeString(viter335)
3064 chandransh 16162 
      oprot.writeMapEnd()
16163 
      oprot.writeFieldEnd()
1596 ankur.sing 16164 
    oprot.writeFieldStop()
16165 
    oprot.writeStructEnd()
16166 
 
3431 rajveer 16167 
  def validate(self):
16168 
    return
16169 
 
16170 
 
1596 ankur.sing 16171 
  def __repr__(self):
16172 
    L = ['%s=%r' % (key, value)
16173 
      for key, value in self.__dict__.iteritems()]
16174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16175 
 
16176 
  def __eq__(self, other):
16177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16178 
 
16179 
  def __ne__(self, other):
16180 
    return not (self == other)
16181 
 
4910 phani.kuma 16182 
class markAsRTOrders_result:
3064 chandransh 16183 
  """
16184 
  Attributes:
16185 
   - ex
16186 
  """
1596 ankur.sing 16187 
 
1627 ankur.sing 16188 
  thrift_spec = (
3064 chandransh 16189 
    None, # 0
16190 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 16191 
  )
16192 
 
3064 chandransh 16193 
  def __init__(self, ex=None,):
16194 
    self.ex = ex
16195 
 
1627 ankur.sing 16196 
  def read(self, iprot):
16197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16199 
      return
16200 
    iprot.readStructBegin()
16201 
    while True:
16202 
      (fname, ftype, fid) = iprot.readFieldBegin()
16203 
      if ftype == TType.STOP:
16204 
        break
3064 chandransh 16205 
      if fid == 1:
16206 
        if ftype == TType.STRUCT:
16207 
          self.ex = TransactionServiceException()
16208 
          self.ex.read(iprot)
16209 
        else:
16210 
          iprot.skip(ftype)
1627 ankur.sing 16211 
      else:
16212 
        iprot.skip(ftype)
16213 
      iprot.readFieldEnd()
16214 
    iprot.readStructEnd()
16215 
 
16216 
  def write(self, oprot):
16217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16219 
      return
4910 phani.kuma 16220 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 16221 
    if self.ex is not None:
3064 chandransh 16222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16223 
      self.ex.write(oprot)
16224 
      oprot.writeFieldEnd()
1627 ankur.sing 16225 
    oprot.writeFieldStop()
16226 
    oprot.writeStructEnd()
16227 
 
3431 rajveer 16228 
  def validate(self):
16229 
    return
16230 
 
16231 
 
1627 ankur.sing 16232 
  def __repr__(self):
16233 
    L = ['%s=%r' % (key, value)
16234 
      for key, value in self.__dict__.iteritems()]
16235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16236 
 
16237 
  def __eq__(self, other):
16238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16239 
 
16240 
  def __ne__(self, other):
16241 
    return not (self == other)
16242 
 
4910 phani.kuma 16243 
class getRTOrders_args:
16244 
  """
16245 
  Attributes:
16246 
   - providerId
16247 
  """
16248 
 
16249 
  thrift_spec = (
16250 
    None, # 0
16251 
    (1, TType.I64, 'providerId', None, None, ), # 1
16252 
  )
16253 
 
16254 
  def __init__(self, providerId=None,):
16255 
    self.providerId = providerId
16256 
 
16257 
  def read(self, iprot):
16258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16260 
      return
16261 
    iprot.readStructBegin()
16262 
    while True:
16263 
      (fname, ftype, fid) = iprot.readFieldBegin()
16264 
      if ftype == TType.STOP:
16265 
        break
16266 
      if fid == 1:
16267 
        if ftype == TType.I64:
16268 
          self.providerId = iprot.readI64();
16269 
        else:
16270 
          iprot.skip(ftype)
16271 
      else:
16272 
        iprot.skip(ftype)
16273 
      iprot.readFieldEnd()
16274 
    iprot.readStructEnd()
16275 
 
16276 
  def write(self, oprot):
16277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16279 
      return
16280 
    oprot.writeStructBegin('getRTOrders_args')
16281 
    if self.providerId is not None:
16282 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16283 
      oprot.writeI64(self.providerId)
16284 
      oprot.writeFieldEnd()
16285 
    oprot.writeFieldStop()
16286 
    oprot.writeStructEnd()
16287 
 
16288 
  def validate(self):
16289 
    return
16290 
 
16291 
 
16292 
  def __repr__(self):
16293 
    L = ['%s=%r' % (key, value)
16294 
      for key, value in self.__dict__.iteritems()]
16295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16296 
 
16297 
  def __eq__(self, other):
16298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16299 
 
16300 
  def __ne__(self, other):
16301 
    return not (self == other)
16302 
 
16303 
class getRTOrders_result:
16304 
  """
16305 
  Attributes:
16306 
   - success
16307 
  """
16308 
 
16309 
  thrift_spec = (
16310 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16311 
  )
16312 
 
16313 
  def __init__(self, success=None,):
16314 
    self.success = success
16315 
 
16316 
  def read(self, iprot):
16317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16319 
      return
16320 
    iprot.readStructBegin()
16321 
    while True:
16322 
      (fname, ftype, fid) = iprot.readFieldBegin()
16323 
      if ftype == TType.STOP:
16324 
        break
16325 
      if fid == 0:
16326 
        if ftype == TType.LIST:
16327 
          self.success = []
6188 rajveer 16328 
          (_etype339, _size336) = iprot.readListBegin()
16329 
          for _i340 in xrange(_size336):
16330 
            _elem341 = Order()
16331 
            _elem341.read(iprot)
16332 
            self.success.append(_elem341)
4910 phani.kuma 16333 
          iprot.readListEnd()
16334 
        else:
16335 
          iprot.skip(ftype)
16336 
      else:
16337 
        iprot.skip(ftype)
16338 
      iprot.readFieldEnd()
16339 
    iprot.readStructEnd()
16340 
 
16341 
  def write(self, oprot):
16342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16344 
      return
16345 
    oprot.writeStructBegin('getRTOrders_result')
16346 
    if self.success is not None:
16347 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16348 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16349 
      for iter342 in self.success:
16350 
        iter342.write(oprot)
4910 phani.kuma 16351 
      oprot.writeListEnd()
16352 
      oprot.writeFieldEnd()
16353 
    oprot.writeFieldStop()
16354 
    oprot.writeStructEnd()
16355 
 
16356 
  def validate(self):
16357 
    return
16358 
 
16359 
 
16360 
  def __repr__(self):
16361 
    L = ['%s=%r' % (key, value)
16362 
      for key, value in self.__dict__.iteritems()]
16363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16364 
 
16365 
  def __eq__(self, other):
16366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16367 
 
16368 
  def __ne__(self, other):
16369 
    return not (self == other)
16370 
 
3064 chandransh 16371 
class updateNonDeliveryReason_args:
1627 ankur.sing 16372 
  """
16373 
  Attributes:
3064 chandransh 16374 
   - providerId
16375 
   - undeliveredOrders
1627 ankur.sing 16376 
  """
16377 
 
16378 
  thrift_spec = (
3064 chandransh 16379 
    None, # 0
16380 
    (1, TType.I64, 'providerId', None, None, ), # 1
16381 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 16382 
  )
16383 
 
3064 chandransh 16384 
  def __init__(self, providerId=None, undeliveredOrders=None,):
16385 
    self.providerId = providerId
16386 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 16387 
 
16388 
  def read(self, iprot):
16389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16391 
      return
16392 
    iprot.readStructBegin()
16393 
    while True:
16394 
      (fname, ftype, fid) = iprot.readFieldBegin()
16395 
      if ftype == TType.STOP:
16396 
        break
3064 chandransh 16397 
      if fid == 1:
1627 ankur.sing 16398 
        if ftype == TType.I64:
3064 chandransh 16399 
          self.providerId = iprot.readI64();
1627 ankur.sing 16400 
        else:
16401 
          iprot.skip(ftype)
3064 chandransh 16402 
      elif fid == 2:
16403 
        if ftype == TType.MAP:
16404 
          self.undeliveredOrders = {}
6188 rajveer 16405 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
16406 
          for _i347 in xrange(_size343):
16407 
            _key348 = iprot.readString();
16408 
            _val349 = iprot.readString();
16409 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 16410 
          iprot.readMapEnd()
16411 
        else:
16412 
          iprot.skip(ftype)
1627 ankur.sing 16413 
      else:
16414 
        iprot.skip(ftype)
16415 
      iprot.readFieldEnd()
16416 
    iprot.readStructEnd()
16417 
 
16418 
  def write(self, oprot):
16419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16421 
      return
3064 chandransh 16422 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 16423 
    if self.providerId is not None:
3064 chandransh 16424 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16425 
      oprot.writeI64(self.providerId)
1627 ankur.sing 16426 
      oprot.writeFieldEnd()
3431 rajveer 16427 
    if self.undeliveredOrders is not None:
3064 chandransh 16428 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
16429 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 16430 
      for kiter350,viter351 in self.undeliveredOrders.items():
16431 
        oprot.writeString(kiter350)
16432 
        oprot.writeString(viter351)
3064 chandransh 16433 
      oprot.writeMapEnd()
16434 
      oprot.writeFieldEnd()
1627 ankur.sing 16435 
    oprot.writeFieldStop()
16436 
    oprot.writeStructEnd()
16437 
 
3431 rajveer 16438 
  def validate(self):
16439 
    return
16440 
 
16441 
 
1627 ankur.sing 16442 
  def __repr__(self):
16443 
    L = ['%s=%r' % (key, value)
16444 
      for key, value in self.__dict__.iteritems()]
16445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16446 
 
16447 
  def __eq__(self, other):
16448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16449 
 
16450 
  def __ne__(self, other):
16451 
    return not (self == other)
16452 
 
3064 chandransh 16453 
class updateNonDeliveryReason_result:
1627 ankur.sing 16454 
  """
16455 
  Attributes:
3064 chandransh 16456 
   - ex
1627 ankur.sing 16457 
  """
16458 
 
16459 
  thrift_spec = (
4910 phani.kuma 16460 
    None, # 0
3064 chandransh 16461 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 16462 
  )
16463 
 
4910 phani.kuma 16464 
  def __init__(self, ex=None,):
3064 chandransh 16465 
    self.ex = ex
1627 ankur.sing 16466 
 
16467 
  def read(self, iprot):
16468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16470 
      return
16471 
    iprot.readStructBegin()
16472 
    while True:
16473 
      (fname, ftype, fid) = iprot.readFieldBegin()
16474 
      if ftype == TType.STOP:
16475 
        break
4910 phani.kuma 16476 
      if fid == 1:
16477 
        if ftype == TType.STRUCT:
16478 
          self.ex = TransactionServiceException()
16479 
          self.ex.read(iprot)
16480 
        else:
16481 
          iprot.skip(ftype)
16482 
      else:
16483 
        iprot.skip(ftype)
16484 
      iprot.readFieldEnd()
16485 
    iprot.readStructEnd()
16486 
 
16487 
  def write(self, oprot):
16488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16490 
      return
16491 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
16492 
    if self.ex is not None:
16493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16494 
      self.ex.write(oprot)
16495 
      oprot.writeFieldEnd()
16496 
    oprot.writeFieldStop()
16497 
    oprot.writeStructEnd()
16498 
 
16499 
  def validate(self):
16500 
    return
16501 
 
16502 
 
16503 
  def __repr__(self):
16504 
    L = ['%s=%r' % (key, value)
16505 
      for key, value in self.__dict__.iteritems()]
16506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16507 
 
16508 
  def __eq__(self, other):
16509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16510 
 
16511 
  def __ne__(self, other):
16512 
    return not (self == other)
16513 
 
16514 
class getNonDeliveredOrdersbyCourier_args:
16515 
  """
16516 
  Attributes:
16517 
   - providerId
16518 
  """
16519 
 
16520 
  thrift_spec = (
16521 
    None, # 0
16522 
    (1, TType.I64, 'providerId', None, None, ), # 1
16523 
  )
16524 
 
16525 
  def __init__(self, providerId=None,):
16526 
    self.providerId = providerId
16527 
 
16528 
  def read(self, iprot):
16529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16531 
      return
16532 
    iprot.readStructBegin()
16533 
    while True:
16534 
      (fname, ftype, fid) = iprot.readFieldBegin()
16535 
      if ftype == TType.STOP:
16536 
        break
16537 
      if fid == 1:
16538 
        if ftype == TType.I64:
16539 
          self.providerId = iprot.readI64();
16540 
        else:
16541 
          iprot.skip(ftype)
16542 
      else:
16543 
        iprot.skip(ftype)
16544 
      iprot.readFieldEnd()
16545 
    iprot.readStructEnd()
16546 
 
16547 
  def write(self, oprot):
16548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16550 
      return
16551 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
16552 
    if self.providerId is not None:
16553 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16554 
      oprot.writeI64(self.providerId)
16555 
      oprot.writeFieldEnd()
16556 
    oprot.writeFieldStop()
16557 
    oprot.writeStructEnd()
16558 
 
16559 
  def validate(self):
16560 
    return
16561 
 
16562 
 
16563 
  def __repr__(self):
16564 
    L = ['%s=%r' % (key, value)
16565 
      for key, value in self.__dict__.iteritems()]
16566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16567 
 
16568 
  def __eq__(self, other):
16569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16570 
 
16571 
  def __ne__(self, other):
16572 
    return not (self == other)
16573 
 
16574 
class getNonDeliveredOrdersbyCourier_result:
16575 
  """
16576 
  Attributes:
16577 
   - success
16578 
  """
16579 
 
16580 
  thrift_spec = (
16581 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16582 
  )
16583 
 
16584 
  def __init__(self, success=None,):
16585 
    self.success = success
16586 
 
16587 
  def read(self, iprot):
16588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16590 
      return
16591 
    iprot.readStructBegin()
16592 
    while True:
16593 
      (fname, ftype, fid) = iprot.readFieldBegin()
16594 
      if ftype == TType.STOP:
16595 
        break
4581 phani.kuma 16596 
      if fid == 0:
16597 
        if ftype == TType.LIST:
16598 
          self.success = []
6188 rajveer 16599 
          (_etype355, _size352) = iprot.readListBegin()
16600 
          for _i356 in xrange(_size352):
16601 
            _elem357 = Order()
16602 
            _elem357.read(iprot)
16603 
            self.success.append(_elem357)
4581 phani.kuma 16604 
          iprot.readListEnd()
16605 
        else:
16606 
          iprot.skip(ftype)
4910 phani.kuma 16607 
      else:
16608 
        iprot.skip(ftype)
16609 
      iprot.readFieldEnd()
16610 
    iprot.readStructEnd()
16611 
 
16612 
  def write(self, oprot):
16613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16615 
      return
16616 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
16617 
    if self.success is not None:
16618 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16619 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16620 
      for iter358 in self.success:
16621 
        iter358.write(oprot)
4910 phani.kuma 16622 
      oprot.writeListEnd()
16623 
      oprot.writeFieldEnd()
16624 
    oprot.writeFieldStop()
16625 
    oprot.writeStructEnd()
16626 
 
16627 
  def validate(self):
16628 
    return
16629 
 
16630 
 
16631 
  def __repr__(self):
16632 
    L = ['%s=%r' % (key, value)
16633 
      for key, value in self.__dict__.iteritems()]
16634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16635 
 
16636 
  def __eq__(self, other):
16637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16638 
 
16639 
  def __ne__(self, other):
16640 
    return not (self == other)
16641 
 
16642 
class markOrdersAsLocalConnected_args:
16643 
  """
16644 
  Attributes:
16645 
   - providerId
16646 
   - local_connected_orders
16647 
  """
16648 
 
16649 
  thrift_spec = (
16650 
    None, # 0
16651 
    (1, TType.I64, 'providerId', None, None, ), # 1
16652 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16653 
  )
16654 
 
16655 
  def __init__(self, providerId=None, local_connected_orders=None,):
16656 
    self.providerId = providerId
16657 
    self.local_connected_orders = local_connected_orders
16658 
 
16659 
  def read(self, iprot):
16660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16662 
      return
16663 
    iprot.readStructBegin()
16664 
    while True:
16665 
      (fname, ftype, fid) = iprot.readFieldBegin()
16666 
      if ftype == TType.STOP:
16667 
        break
16668 
      if fid == 1:
16669 
        if ftype == TType.I64:
16670 
          self.providerId = iprot.readI64();
16671 
        else:
16672 
          iprot.skip(ftype)
16673 
      elif fid == 2:
16674 
        if ftype == TType.MAP:
16675 
          self.local_connected_orders = {}
6188 rajveer 16676 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16677 
          for _i363 in xrange(_size359):
16678 
            _key364 = iprot.readString();
16679 
            _val365 = iprot.readString();
16680 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16681 
          iprot.readMapEnd()
16682 
        else:
16683 
          iprot.skip(ftype)
16684 
      else:
16685 
        iprot.skip(ftype)
16686 
      iprot.readFieldEnd()
16687 
    iprot.readStructEnd()
16688 
 
16689 
  def write(self, oprot):
16690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16692 
      return
16693 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16694 
    if self.providerId is not None:
16695 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16696 
      oprot.writeI64(self.providerId)
16697 
      oprot.writeFieldEnd()
16698 
    if self.local_connected_orders is not None:
16699 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16700 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16701 
      for kiter366,viter367 in self.local_connected_orders.items():
16702 
        oprot.writeString(kiter366)
16703 
        oprot.writeString(viter367)
4910 phani.kuma 16704 
      oprot.writeMapEnd()
16705 
      oprot.writeFieldEnd()
16706 
    oprot.writeFieldStop()
16707 
    oprot.writeStructEnd()
16708 
 
16709 
  def validate(self):
16710 
    return
16711 
 
16712 
 
16713 
  def __repr__(self):
16714 
    L = ['%s=%r' % (key, value)
16715 
      for key, value in self.__dict__.iteritems()]
16716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16717 
 
16718 
  def __eq__(self, other):
16719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16720 
 
16721 
  def __ne__(self, other):
16722 
    return not (self == other)
16723 
 
16724 
class markOrdersAsLocalConnected_result:
16725 
  """
16726 
  Attributes:
16727 
   - ex
16728 
  """
16729 
 
16730 
  thrift_spec = (
16731 
    None, # 0
16732 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16733 
  )
16734 
 
16735 
  def __init__(self, ex=None,):
16736 
    self.ex = ex
16737 
 
16738 
  def read(self, iprot):
16739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16741 
      return
16742 
    iprot.readStructBegin()
16743 
    while True:
16744 
      (fname, ftype, fid) = iprot.readFieldBegin()
16745 
      if ftype == TType.STOP:
16746 
        break
16747 
      if fid == 1:
3064 chandransh 16748 
        if ftype == TType.STRUCT:
16749 
          self.ex = TransactionServiceException()
16750 
          self.ex.read(iprot)
1627 ankur.sing 16751 
        else:
16752 
          iprot.skip(ftype)
16753 
      else:
16754 
        iprot.skip(ftype)
16755 
      iprot.readFieldEnd()
16756 
    iprot.readStructEnd()
16757 
 
16758 
  def write(self, oprot):
16759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16761 
      return
4910 phani.kuma 16762 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16763 
    if self.ex is not None:
16764 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16765 
      self.ex.write(oprot)
16766 
      oprot.writeFieldEnd()
16767 
    oprot.writeFieldStop()
16768 
    oprot.writeStructEnd()
16769 
 
16770 
  def validate(self):
16771 
    return
16772 
 
16773 
 
16774 
  def __repr__(self):
16775 
    L = ['%s=%r' % (key, value)
16776 
      for key, value in self.__dict__.iteritems()]
16777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16778 
 
16779 
  def __eq__(self, other):
16780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16781 
 
16782 
  def __ne__(self, other):
16783 
    return not (self == other)
16784 
 
16785 
class getOrdersNotLocalConnected_args:
16786 
  """
16787 
  Attributes:
16788 
   - providerId
16789 
  """
16790 
 
16791 
  thrift_spec = (
16792 
    None, # 0
16793 
    (1, TType.I64, 'providerId', None, None, ), # 1
16794 
  )
16795 
 
16796 
  def __init__(self, providerId=None,):
16797 
    self.providerId = providerId
16798 
 
16799 
  def read(self, iprot):
16800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16802 
      return
16803 
    iprot.readStructBegin()
16804 
    while True:
16805 
      (fname, ftype, fid) = iprot.readFieldBegin()
16806 
      if ftype == TType.STOP:
16807 
        break
16808 
      if fid == 1:
16809 
        if ftype == TType.I64:
16810 
          self.providerId = iprot.readI64();
16811 
        else:
16812 
          iprot.skip(ftype)
16813 
      else:
16814 
        iprot.skip(ftype)
16815 
      iprot.readFieldEnd()
16816 
    iprot.readStructEnd()
16817 
 
16818 
  def write(self, oprot):
16819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16821 
      return
16822 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16823 
    if self.providerId is not None:
16824 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16825 
      oprot.writeI64(self.providerId)
16826 
      oprot.writeFieldEnd()
16827 
    oprot.writeFieldStop()
16828 
    oprot.writeStructEnd()
16829 
 
16830 
  def validate(self):
16831 
    return
16832 
 
16833 
 
16834 
  def __repr__(self):
16835 
    L = ['%s=%r' % (key, value)
16836 
      for key, value in self.__dict__.iteritems()]
16837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16838 
 
16839 
  def __eq__(self, other):
16840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16841 
 
16842 
  def __ne__(self, other):
16843 
    return not (self == other)
16844 
 
16845 
class getOrdersNotLocalConnected_result:
16846 
  """
16847 
  Attributes:
16848 
   - success
16849 
  """
16850 
 
16851 
  thrift_spec = (
16852 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16853 
  )
16854 
 
16855 
  def __init__(self, success=None,):
16856 
    self.success = success
16857 
 
16858 
  def read(self, iprot):
16859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16861 
      return
16862 
    iprot.readStructBegin()
16863 
    while True:
16864 
      (fname, ftype, fid) = iprot.readFieldBegin()
16865 
      if ftype == TType.STOP:
16866 
        break
16867 
      if fid == 0:
16868 
        if ftype == TType.LIST:
16869 
          self.success = []
6188 rajveer 16870 
          (_etype371, _size368) = iprot.readListBegin()
16871 
          for _i372 in xrange(_size368):
16872 
            _elem373 = Order()
16873 
            _elem373.read(iprot)
16874 
            self.success.append(_elem373)
4910 phani.kuma 16875 
          iprot.readListEnd()
16876 
        else:
16877 
          iprot.skip(ftype)
16878 
      else:
16879 
        iprot.skip(ftype)
16880 
      iprot.readFieldEnd()
16881 
    iprot.readStructEnd()
16882 
 
16883 
  def write(self, oprot):
16884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16886 
      return
16887 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16888 
    if self.success is not None:
16889 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16890 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16891 
      for iter374 in self.success:
16892 
        iter374.write(oprot)
4581 phani.kuma 16893 
      oprot.writeListEnd()
16894 
      oprot.writeFieldEnd()
4910 phani.kuma 16895 
    oprot.writeFieldStop()
16896 
    oprot.writeStructEnd()
16897 
 
16898 
  def validate(self):
16899 
    return
16900 
 
16901 
 
16902 
  def __repr__(self):
16903 
    L = ['%s=%r' % (key, value)
16904 
      for key, value in self.__dict__.iteritems()]
16905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16906 
 
16907 
  def __eq__(self, other):
16908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16909 
 
16910 
  def __ne__(self, other):
16911 
    return not (self == other)
16912 
 
16913 
class markOrdersAsDestinationCityReached_args:
16914 
  """
16915 
  Attributes:
16916 
   - providerId
16917 
   - destination_city_reached_orders
16918 
  """
16919 
 
16920 
  thrift_spec = (
16921 
    None, # 0
16922 
    (1, TType.I64, 'providerId', None, None, ), # 1
16923 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16924 
  )
16925 
 
16926 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16927 
    self.providerId = providerId
16928 
    self.destination_city_reached_orders = destination_city_reached_orders
16929 
 
16930 
  def read(self, iprot):
16931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16933 
      return
16934 
    iprot.readStructBegin()
16935 
    while True:
16936 
      (fname, ftype, fid) = iprot.readFieldBegin()
16937 
      if ftype == TType.STOP:
16938 
        break
16939 
      if fid == 1:
16940 
        if ftype == TType.I64:
16941 
          self.providerId = iprot.readI64();
16942 
        else:
16943 
          iprot.skip(ftype)
16944 
      elif fid == 2:
16945 
        if ftype == TType.MAP:
16946 
          self.destination_city_reached_orders = {}
6188 rajveer 16947 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16948 
          for _i379 in xrange(_size375):
16949 
            _key380 = iprot.readString();
16950 
            _val381 = iprot.readString();
16951 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16952 
          iprot.readMapEnd()
16953 
        else:
16954 
          iprot.skip(ftype)
16955 
      else:
16956 
        iprot.skip(ftype)
16957 
      iprot.readFieldEnd()
16958 
    iprot.readStructEnd()
16959 
 
16960 
  def write(self, oprot):
16961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16963 
      return
16964 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16965 
    if self.providerId is not None:
16966 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16967 
      oprot.writeI64(self.providerId)
16968 
      oprot.writeFieldEnd()
16969 
    if self.destination_city_reached_orders is not None:
16970 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16971 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16972 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16973 
        oprot.writeString(kiter382)
16974 
        oprot.writeString(viter383)
4910 phani.kuma 16975 
      oprot.writeMapEnd()
16976 
      oprot.writeFieldEnd()
16977 
    oprot.writeFieldStop()
16978 
    oprot.writeStructEnd()
16979 
 
16980 
  def validate(self):
16981 
    return
16982 
 
16983 
 
16984 
  def __repr__(self):
16985 
    L = ['%s=%r' % (key, value)
16986 
      for key, value in self.__dict__.iteritems()]
16987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16988 
 
16989 
  def __eq__(self, other):
16990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16991 
 
16992 
  def __ne__(self, other):
16993 
    return not (self == other)
16994 
 
16995 
class markOrdersAsDestinationCityReached_result:
16996 
  """
16997 
  Attributes:
16998 
   - ex
16999 
  """
17000 
 
17001 
  thrift_spec = (
17002 
    None, # 0
17003 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17004 
  )
17005 
 
17006 
  def __init__(self, ex=None,):
17007 
    self.ex = ex
17008 
 
17009 
  def read(self, iprot):
17010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17012 
      return
17013 
    iprot.readStructBegin()
17014 
    while True:
17015 
      (fname, ftype, fid) = iprot.readFieldBegin()
17016 
      if ftype == TType.STOP:
17017 
        break
17018 
      if fid == 1:
17019 
        if ftype == TType.STRUCT:
17020 
          self.ex = TransactionServiceException()
17021 
          self.ex.read(iprot)
17022 
        else:
17023 
          iprot.skip(ftype)
17024 
      else:
17025 
        iprot.skip(ftype)
17026 
      iprot.readFieldEnd()
17027 
    iprot.readStructEnd()
17028 
 
17029 
  def write(self, oprot):
17030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17032 
      return
17033 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 17034 
    if self.ex is not None:
3064 chandransh 17035 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17036 
      self.ex.write(oprot)
1627 ankur.sing 17037 
      oprot.writeFieldEnd()
17038 
    oprot.writeFieldStop()
17039 
    oprot.writeStructEnd()
17040 
 
3431 rajveer 17041 
  def validate(self):
17042 
    return
17043 
 
17044 
 
1627 ankur.sing 17045 
  def __repr__(self):
17046 
    L = ['%s=%r' % (key, value)
17047 
      for key, value in self.__dict__.iteritems()]
17048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17049 
 
17050 
  def __eq__(self, other):
17051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17052 
 
17053 
  def __ne__(self, other):
17054 
    return not (self == other)
17055 
 
4910 phani.kuma 17056 
class markOrdersAsFirstDeliveryAttempted_args:
17057 
  """
17058 
  Attributes:
17059 
   - providerId
17060 
   - first_atdl_orders
17061 
  """
17062 
 
17063 
  thrift_spec = (
17064 
    None, # 0
17065 
    (1, TType.I64, 'providerId', None, None, ), # 1
17066 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
17067 
  )
17068 
 
17069 
  def __init__(self, providerId=None, first_atdl_orders=None,):
17070 
    self.providerId = providerId
17071 
    self.first_atdl_orders = first_atdl_orders
17072 
 
17073 
  def read(self, iprot):
17074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17076 
      return
17077 
    iprot.readStructBegin()
17078 
    while True:
17079 
      (fname, ftype, fid) = iprot.readFieldBegin()
17080 
      if ftype == TType.STOP:
17081 
        break
17082 
      if fid == 1:
17083 
        if ftype == TType.I64:
17084 
          self.providerId = iprot.readI64();
17085 
        else:
17086 
          iprot.skip(ftype)
17087 
      elif fid == 2:
17088 
        if ftype == TType.MAP:
17089 
          self.first_atdl_orders = {}
6188 rajveer 17090 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
17091 
          for _i388 in xrange(_size384):
17092 
            _key389 = iprot.readString();
17093 
            _val390 = iprot.readString();
17094 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 17095 
          iprot.readMapEnd()
17096 
        else:
17097 
          iprot.skip(ftype)
17098 
      else:
17099 
        iprot.skip(ftype)
17100 
      iprot.readFieldEnd()
17101 
    iprot.readStructEnd()
17102 
 
17103 
  def write(self, oprot):
17104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17106 
      return
17107 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
17108 
    if self.providerId is not None:
17109 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17110 
      oprot.writeI64(self.providerId)
17111 
      oprot.writeFieldEnd()
17112 
    if self.first_atdl_orders is not None:
17113 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
17114 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 17115 
      for kiter391,viter392 in self.first_atdl_orders.items():
17116 
        oprot.writeString(kiter391)
17117 
        oprot.writeString(viter392)
4910 phani.kuma 17118 
      oprot.writeMapEnd()
17119 
      oprot.writeFieldEnd()
17120 
    oprot.writeFieldStop()
17121 
    oprot.writeStructEnd()
17122 
 
17123 
  def validate(self):
17124 
    return
17125 
 
17126 
 
17127 
  def __repr__(self):
17128 
    L = ['%s=%r' % (key, value)
17129 
      for key, value in self.__dict__.iteritems()]
17130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17131 
 
17132 
  def __eq__(self, other):
17133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17134 
 
17135 
  def __ne__(self, other):
17136 
    return not (self == other)
17137 
 
17138 
class markOrdersAsFirstDeliveryAttempted_result:
17139 
  """
17140 
  Attributes:
17141 
   - ex
17142 
  """
17143 
 
17144 
  thrift_spec = (
17145 
    None, # 0
17146 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17147 
  )
17148 
 
17149 
  def __init__(self, ex=None,):
17150 
    self.ex = ex
17151 
 
17152 
  def read(self, iprot):
17153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17155 
      return
17156 
    iprot.readStructBegin()
17157 
    while True:
17158 
      (fname, ftype, fid) = iprot.readFieldBegin()
17159 
      if ftype == TType.STOP:
17160 
        break
17161 
      if fid == 1:
17162 
        if ftype == TType.STRUCT:
17163 
          self.ex = TransactionServiceException()
17164 
          self.ex.read(iprot)
17165 
        else:
17166 
          iprot.skip(ftype)
17167 
      else:
17168 
        iprot.skip(ftype)
17169 
      iprot.readFieldEnd()
17170 
    iprot.readStructEnd()
17171 
 
17172 
  def write(self, oprot):
17173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17175 
      return
17176 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
17177 
    if self.ex is not None:
17178 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17179 
      self.ex.write(oprot)
17180 
      oprot.writeFieldEnd()
17181 
    oprot.writeFieldStop()
17182 
    oprot.writeStructEnd()
17183 
 
17184 
  def validate(self):
17185 
    return
17186 
 
17187 
 
17188 
  def __repr__(self):
17189 
    L = ['%s=%r' % (key, value)
17190 
      for key, value in self.__dict__.iteritems()]
17191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17192 
 
17193 
  def __eq__(self, other):
17194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17195 
 
17196 
  def __ne__(self, other):
17197 
    return not (self == other)
17198 
 
3064 chandransh 17199 
class getUndeliveredOrders_args:
1886 ankur.sing 17200 
  """
17201 
  Attributes:
3064 chandransh 17202 
   - providerId
17203 
   - warehouseId
1886 ankur.sing 17204 
  """
1627 ankur.sing 17205 
 
1886 ankur.sing 17206 
  thrift_spec = (
17207 
    None, # 0
3064 chandransh 17208 
    (1, TType.I64, 'providerId', None, None, ), # 1
17209 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 17210 
  )
17211 
 
3064 chandransh 17212 
  def __init__(self, providerId=None, warehouseId=None,):
17213 
    self.providerId = providerId
17214 
    self.warehouseId = warehouseId
1886 ankur.sing 17215 
 
17216 
  def read(self, iprot):
17217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17219 
      return
17220 
    iprot.readStructBegin()
17221 
    while True:
17222 
      (fname, ftype, fid) = iprot.readFieldBegin()
17223 
      if ftype == TType.STOP:
17224 
        break
17225 
      if fid == 1:
17226 
        if ftype == TType.I64:
3064 chandransh 17227 
          self.providerId = iprot.readI64();
1886 ankur.sing 17228 
        else:
17229 
          iprot.skip(ftype)
3064 chandransh 17230 
      elif fid == 2:
17231 
        if ftype == TType.I64:
17232 
          self.warehouseId = iprot.readI64();
17233 
        else:
17234 
          iprot.skip(ftype)
1886 ankur.sing 17235 
      else:
17236 
        iprot.skip(ftype)
17237 
      iprot.readFieldEnd()
17238 
    iprot.readStructEnd()
17239 
 
17240 
  def write(self, oprot):
17241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17243 
      return
3064 chandransh 17244 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 17245 
    if self.providerId is not None:
3064 chandransh 17246 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17247 
      oprot.writeI64(self.providerId)
1886 ankur.sing 17248 
      oprot.writeFieldEnd()
3431 rajveer 17249 
    if self.warehouseId is not None:
3064 chandransh 17250 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17251 
      oprot.writeI64(self.warehouseId)
17252 
      oprot.writeFieldEnd()
1886 ankur.sing 17253 
    oprot.writeFieldStop()
17254 
    oprot.writeStructEnd()
17255 
 
3431 rajveer 17256 
  def validate(self):
17257 
    return
17258 
 
17259 
 
1886 ankur.sing 17260 
  def __repr__(self):
17261 
    L = ['%s=%r' % (key, value)
17262 
      for key, value in self.__dict__.iteritems()]
17263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17264 
 
17265 
  def __eq__(self, other):
17266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17267 
 
17268 
  def __ne__(self, other):
17269 
    return not (self == other)
17270 
 
3064 chandransh 17271 
class getUndeliveredOrders_result:
1886 ankur.sing 17272 
  """
17273 
  Attributes:
17274 
   - success
17275 
  """
17276 
 
17277 
  thrift_spec = (
17278 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17279 
  )
17280 
 
17281 
  def __init__(self, success=None,):
17282 
    self.success = success
17283 
 
17284 
  def read(self, iprot):
17285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17287 
      return
17288 
    iprot.readStructBegin()
17289 
    while True:
17290 
      (fname, ftype, fid) = iprot.readFieldBegin()
17291 
      if ftype == TType.STOP:
17292 
        break
17293 
      if fid == 0:
17294 
        if ftype == TType.LIST:
17295 
          self.success = []
6188 rajveer 17296 
          (_etype396, _size393) = iprot.readListBegin()
17297 
          for _i397 in xrange(_size393):
17298 
            _elem398 = Order()
17299 
            _elem398.read(iprot)
17300 
            self.success.append(_elem398)
1886 ankur.sing 17301 
          iprot.readListEnd()
17302 
        else:
17303 
          iprot.skip(ftype)
17304 
      else:
17305 
        iprot.skip(ftype)
17306 
      iprot.readFieldEnd()
17307 
    iprot.readStructEnd()
17308 
 
17309 
  def write(self, oprot):
17310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17312 
      return
3064 chandransh 17313 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 17314 
    if self.success is not None:
1886 ankur.sing 17315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17316 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17317 
      for iter399 in self.success:
17318 
        iter399.write(oprot)
1886 ankur.sing 17319 
      oprot.writeListEnd()
17320 
      oprot.writeFieldEnd()
17321 
    oprot.writeFieldStop()
17322 
    oprot.writeStructEnd()
17323 
 
3431 rajveer 17324 
  def validate(self):
17325 
    return
17326 
 
17327 
 
1886 ankur.sing 17328 
  def __repr__(self):
17329 
    L = ['%s=%r' % (key, value)
17330 
      for key, value in self.__dict__.iteritems()]
17331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17332 
 
17333 
  def __eq__(self, other):
17334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17335 
 
17336 
  def __ne__(self, other):
17337 
    return not (self == other)
17338 
 
4783 phani.kuma 17339 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
17340 
 
17341 
  thrift_spec = (
17342 
  )
17343 
 
17344 
  def read(self, iprot):
17345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17347 
      return
17348 
    iprot.readStructBegin()
17349 
    while True:
17350 
      (fname, ftype, fid) = iprot.readFieldBegin()
17351 
      if ftype == TType.STOP:
17352 
        break
17353 
      else:
17354 
        iprot.skip(ftype)
17355 
      iprot.readFieldEnd()
17356 
    iprot.readStructEnd()
17357 
 
17358 
  def write(self, oprot):
17359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17361 
      return
17362 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
17363 
    oprot.writeFieldStop()
17364 
    oprot.writeStructEnd()
17365 
 
17366 
  def validate(self):
17367 
    return
17368 
 
17369 
 
17370 
  def __repr__(self):
17371 
    L = ['%s=%r' % (key, value)
17372 
      for key, value in self.__dict__.iteritems()]
17373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17374 
 
17375 
  def __eq__(self, other):
17376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17377 
 
17378 
  def __ne__(self, other):
17379 
    return not (self == other)
17380 
 
17381 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
17382 
  """
17383 
  Attributes:
17384 
   - success
17385 
  """
17386 
 
17387 
  thrift_spec = (
17388 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17389 
  )
17390 
 
17391 
  def __init__(self, success=None,):
17392 
    self.success = success
17393 
 
17394 
  def read(self, iprot):
17395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17397 
      return
17398 
    iprot.readStructBegin()
17399 
    while True:
17400 
      (fname, ftype, fid) = iprot.readFieldBegin()
17401 
      if ftype == TType.STOP:
17402 
        break
17403 
      if fid == 0:
17404 
        if ftype == TType.LIST:
17405 
          self.success = []
6188 rajveer 17406 
          (_etype403, _size400) = iprot.readListBegin()
17407 
          for _i404 in xrange(_size400):
17408 
            _elem405 = Order()
17409 
            _elem405.read(iprot)
17410 
            self.success.append(_elem405)
4783 phani.kuma 17411 
          iprot.readListEnd()
17412 
        else:
17413 
          iprot.skip(ftype)
17414 
      else:
17415 
        iprot.skip(ftype)
17416 
      iprot.readFieldEnd()
17417 
    iprot.readStructEnd()
17418 
 
17419 
  def write(self, oprot):
17420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17422 
      return
17423 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
17424 
    if self.success is not None:
17425 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17426 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17427 
      for iter406 in self.success:
17428 
        iter406.write(oprot)
4783 phani.kuma 17429 
      oprot.writeListEnd()
17430 
      oprot.writeFieldEnd()
17431 
    oprot.writeFieldStop()
17432 
    oprot.writeStructEnd()
17433 
 
17434 
  def validate(self):
17435 
    return
17436 
 
17437 
 
17438 
  def __repr__(self):
17439 
    L = ['%s=%r' % (key, value)
17440 
      for key, value in self.__dict__.iteritems()]
17441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17442 
 
17443 
  def __eq__(self, other):
17444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17445 
 
17446 
  def __ne__(self, other):
17447 
    return not (self == other)
17448 
 
2536 chandransh 17449 
class toggleDOAFlag_args:
17450 
  """
17451 
  Attributes:
17452 
   - orderId
17453 
  """
1886 ankur.sing 17454 
 
2536 chandransh 17455 
  thrift_spec = (
17456 
    None, # 0
17457 
    (1, TType.I64, 'orderId', None, None, ), # 1
17458 
  )
17459 
 
17460 
  def __init__(self, orderId=None,):
17461 
    self.orderId = orderId
17462 
 
17463 
  def read(self, iprot):
17464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17466 
      return
17467 
    iprot.readStructBegin()
17468 
    while True:
17469 
      (fname, ftype, fid) = iprot.readFieldBegin()
17470 
      if ftype == TType.STOP:
17471 
        break
17472 
      if fid == 1:
17473 
        if ftype == TType.I64:
17474 
          self.orderId = iprot.readI64();
17475 
        else:
17476 
          iprot.skip(ftype)
17477 
      else:
17478 
        iprot.skip(ftype)
17479 
      iprot.readFieldEnd()
17480 
    iprot.readStructEnd()
17481 
 
17482 
  def write(self, oprot):
17483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17485 
      return
17486 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 17487 
    if self.orderId is not None:
2536 chandransh 17488 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17489 
      oprot.writeI64(self.orderId)
17490 
      oprot.writeFieldEnd()
17491 
    oprot.writeFieldStop()
17492 
    oprot.writeStructEnd()
17493 
 
3431 rajveer 17494 
  def validate(self):
17495 
    return
17496 
 
17497 
 
2536 chandransh 17498 
  def __repr__(self):
17499 
    L = ['%s=%r' % (key, value)
17500 
      for key, value in self.__dict__.iteritems()]
17501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17502 
 
17503 
  def __eq__(self, other):
17504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17505 
 
17506 
  def __ne__(self, other):
17507 
    return not (self == other)
17508 
 
17509 
class toggleDOAFlag_result:
17510 
  """
17511 
  Attributes:
17512 
   - success
17513 
   - ex
17514 
  """
17515 
 
17516 
  thrift_spec = (
17517 
    (0, TType.BOOL, 'success', None, None, ), # 0
17518 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17519 
  )
17520 
 
17521 
  def __init__(self, success=None, ex=None,):
17522 
    self.success = success
17523 
    self.ex = ex
17524 
 
17525 
  def read(self, iprot):
17526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17528 
      return
17529 
    iprot.readStructBegin()
17530 
    while True:
17531 
      (fname, ftype, fid) = iprot.readFieldBegin()
17532 
      if ftype == TType.STOP:
17533 
        break
17534 
      if fid == 0:
17535 
        if ftype == TType.BOOL:
17536 
          self.success = iprot.readBool();
17537 
        else:
17538 
          iprot.skip(ftype)
17539 
      elif fid == 1:
17540 
        if ftype == TType.STRUCT:
17541 
          self.ex = TransactionServiceException()
17542 
          self.ex.read(iprot)
17543 
        else:
17544 
          iprot.skip(ftype)
17545 
      else:
17546 
        iprot.skip(ftype)
17547 
      iprot.readFieldEnd()
17548 
    iprot.readStructEnd()
17549 
 
17550 
  def write(self, oprot):
17551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17553 
      return
17554 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 17555 
    if self.success is not None:
2536 chandransh 17556 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17557 
      oprot.writeBool(self.success)
17558 
      oprot.writeFieldEnd()
3431 rajveer 17559 
    if self.ex is not None:
2536 chandransh 17560 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17561 
      self.ex.write(oprot)
17562 
      oprot.writeFieldEnd()
17563 
    oprot.writeFieldStop()
17564 
    oprot.writeStructEnd()
17565 
 
3431 rajveer 17566 
  def validate(self):
17567 
    return
17568 
 
17569 
 
2536 chandransh 17570 
  def __repr__(self):
17571 
    L = ['%s=%r' % (key, value)
17572 
      for key, value in self.__dict__.iteritems()]
17573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17574 
 
17575 
  def __eq__(self, other):
17576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17577 
 
17578 
  def __ne__(self, other):
17579 
    return not (self == other)
17580 
 
4712 rajveer 17581 
class markOrderAsDelivered_args:
17582 
  """
17583 
  Attributes:
17584 
   - orderId
17585 
   - deliveryTimestamp
17586 
   - receiver
17587 
  """
17588 
 
17589 
  thrift_spec = None
17590 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
17591 
    self.orderId = orderId
17592 
    self.deliveryTimestamp = deliveryTimestamp
17593 
    self.receiver = receiver
17594 
 
17595 
  def read(self, iprot):
17596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17598 
      return
17599 
    iprot.readStructBegin()
17600 
    while True:
17601 
      (fname, ftype, fid) = iprot.readFieldBegin()
17602 
      if ftype == TType.STOP:
17603 
        break
17604 
      if fid == 1:
17605 
        if ftype == TType.I64:
17606 
          self.orderId = iprot.readI64();
17607 
        else:
17608 
          iprot.skip(ftype)
17609 
      elif fid == 2:
17610 
        if ftype == TType.I64:
17611 
          self.deliveryTimestamp = iprot.readI64();
17612 
        else:
17613 
          iprot.skip(ftype)
17614 
      elif fid == -1:
17615 
        if ftype == TType.STRING:
17616 
          self.receiver = iprot.readString();
17617 
        else:
17618 
          iprot.skip(ftype)
17619 
      else:
17620 
        iprot.skip(ftype)
17621 
      iprot.readFieldEnd()
17622 
    iprot.readStructEnd()
17623 
 
17624 
  def write(self, oprot):
17625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17627 
      return
17628 
    oprot.writeStructBegin('markOrderAsDelivered_args')
17629 
    if self.receiver is not None:
17630 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
17631 
      oprot.writeString(self.receiver)
17632 
      oprot.writeFieldEnd()
17633 
    if self.orderId is not None:
17634 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17635 
      oprot.writeI64(self.orderId)
17636 
      oprot.writeFieldEnd()
17637 
    if self.deliveryTimestamp is not None:
17638 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17639 
      oprot.writeI64(self.deliveryTimestamp)
17640 
      oprot.writeFieldEnd()
17641 
    oprot.writeFieldStop()
17642 
    oprot.writeStructEnd()
17643 
 
17644 
  def validate(self):
17645 
    return
17646 
 
17647 
 
17648 
  def __repr__(self):
17649 
    L = ['%s=%r' % (key, value)
17650 
      for key, value in self.__dict__.iteritems()]
17651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17652 
 
17653 
  def __eq__(self, other):
17654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17655 
 
17656 
  def __ne__(self, other):
17657 
    return not (self == other)
17658 
 
17659 
class markOrderAsDelivered_result:
17660 
  """
17661 
  Attributes:
17662 
   - ex
17663 
  """
17664 
 
17665 
  thrift_spec = (
17666 
    None, # 0
17667 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17668 
  )
17669 
 
17670 
  def __init__(self, ex=None,):
17671 
    self.ex = ex
17672 
 
17673 
  def read(self, iprot):
17674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17676 
      return
17677 
    iprot.readStructBegin()
17678 
    while True:
17679 
      (fname, ftype, fid) = iprot.readFieldBegin()
17680 
      if ftype == TType.STOP:
17681 
        break
17682 
      if fid == 1:
17683 
        if ftype == TType.STRUCT:
17684 
          self.ex = TransactionServiceException()
17685 
          self.ex.read(iprot)
17686 
        else:
17687 
          iprot.skip(ftype)
17688 
      else:
17689 
        iprot.skip(ftype)
17690 
      iprot.readFieldEnd()
17691 
    iprot.readStructEnd()
17692 
 
17693 
  def write(self, oprot):
17694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17696 
      return
17697 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17698 
    if self.ex is not None:
17699 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17700 
      self.ex.write(oprot)
17701 
      oprot.writeFieldEnd()
17702 
    oprot.writeFieldStop()
17703 
    oprot.writeStructEnd()
17704 
 
17705 
  def validate(self):
17706 
    return
17707 
 
17708 
 
17709 
  def __repr__(self):
17710 
    L = ['%s=%r' % (key, value)
17711 
      for key, value in self.__dict__.iteritems()]
17712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17713 
 
17714 
  def __eq__(self, other):
17715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17716 
 
17717 
  def __ne__(self, other):
17718 
    return not (self == other)
17719 
 
5553 rajveer 17720 
class markOrderAsReceivedAtStore_args:
17721 
  """
17722 
  Attributes:
17723 
   - orderId
17724 
   - deliveryTimestamp
17725 
  """
17726 
 
17727 
  thrift_spec = (
17728 
    None, # 0
17729 
    (1, TType.I64, 'orderId', None, None, ), # 1
17730 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17731 
  )
17732 
 
17733 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17734 
    self.orderId = orderId
17735 
    self.deliveryTimestamp = deliveryTimestamp
17736 
 
17737 
  def read(self, iprot):
17738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17740 
      return
17741 
    iprot.readStructBegin()
17742 
    while True:
17743 
      (fname, ftype, fid) = iprot.readFieldBegin()
17744 
      if ftype == TType.STOP:
17745 
        break
17746 
      if fid == 1:
17747 
        if ftype == TType.I64:
17748 
          self.orderId = iprot.readI64();
17749 
        else:
17750 
          iprot.skip(ftype)
17751 
      elif fid == 2:
17752 
        if ftype == TType.I64:
17753 
          self.deliveryTimestamp = iprot.readI64();
17754 
        else:
17755 
          iprot.skip(ftype)
17756 
      else:
17757 
        iprot.skip(ftype)
17758 
      iprot.readFieldEnd()
17759 
    iprot.readStructEnd()
17760 
 
17761 
  def write(self, oprot):
17762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17764 
      return
17765 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17766 
    if self.orderId is not None:
17767 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17768 
      oprot.writeI64(self.orderId)
17769 
      oprot.writeFieldEnd()
17770 
    if self.deliveryTimestamp is not None:
17771 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17772 
      oprot.writeI64(self.deliveryTimestamp)
17773 
      oprot.writeFieldEnd()
17774 
    oprot.writeFieldStop()
17775 
    oprot.writeStructEnd()
17776 
 
17777 
  def validate(self):
17778 
    return
17779 
 
17780 
 
17781 
  def __repr__(self):
17782 
    L = ['%s=%r' % (key, value)
17783 
      for key, value in self.__dict__.iteritems()]
17784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17785 
 
17786 
  def __eq__(self, other):
17787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17788 
 
17789 
  def __ne__(self, other):
17790 
    return not (self == other)
17791 
 
17792 
class markOrderAsReceivedAtStore_result:
17793 
  """
17794 
  Attributes:
17795 
   - ex
17796 
  """
17797 
 
17798 
  thrift_spec = (
17799 
    None, # 0
17800 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17801 
  )
17802 
 
17803 
  def __init__(self, ex=None,):
17804 
    self.ex = ex
17805 
 
17806 
  def read(self, iprot):
17807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17809 
      return
17810 
    iprot.readStructBegin()
17811 
    while True:
17812 
      (fname, ftype, fid) = iprot.readFieldBegin()
17813 
      if ftype == TType.STOP:
17814 
        break
17815 
      if fid == 1:
17816 
        if ftype == TType.STRUCT:
17817 
          self.ex = TransactionServiceException()
17818 
          self.ex.read(iprot)
17819 
        else:
17820 
          iprot.skip(ftype)
17821 
      else:
17822 
        iprot.skip(ftype)
17823 
      iprot.readFieldEnd()
17824 
    iprot.readStructEnd()
17825 
 
17826 
  def write(self, oprot):
17827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17829 
      return
17830 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17831 
    if self.ex is not None:
17832 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17833 
      self.ex.write(oprot)
17834 
      oprot.writeFieldEnd()
17835 
    oprot.writeFieldStop()
17836 
    oprot.writeStructEnd()
17837 
 
17838 
  def validate(self):
17839 
    return
17840 
 
17841 
 
17842 
  def __repr__(self):
17843 
    L = ['%s=%r' % (key, value)
17844 
      for key, value in self.__dict__.iteritems()]
17845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17846 
 
17847 
  def __eq__(self, other):
17848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17849 
 
17850 
  def __ne__(self, other):
17851 
    return not (self == other)
17852 
 
4454 rajveer 17853 
class markOrderDoaRequestReceived_args:
17854 
  """
17855 
  Attributes:
17856 
   - orderId
17857 
  """
17858 
 
17859 
  thrift_spec = (
17860 
    None, # 0
17861 
    (1, TType.I64, 'orderId', None, None, ), # 1
17862 
  )
17863 
 
17864 
  def __init__(self, orderId=None,):
17865 
    self.orderId = orderId
17866 
 
17867 
  def read(self, iprot):
17868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17870 
      return
17871 
    iprot.readStructBegin()
17872 
    while True:
17873 
      (fname, ftype, fid) = iprot.readFieldBegin()
17874 
      if ftype == TType.STOP:
17875 
        break
17876 
      if fid == 1:
17877 
        if ftype == TType.I64:
17878 
          self.orderId = iprot.readI64();
17879 
        else:
17880 
          iprot.skip(ftype)
17881 
      else:
17882 
        iprot.skip(ftype)
17883 
      iprot.readFieldEnd()
17884 
    iprot.readStructEnd()
17885 
 
17886 
  def write(self, oprot):
17887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17889 
      return
17890 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17891 
    if self.orderId is not None:
17892 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17893 
      oprot.writeI64(self.orderId)
17894 
      oprot.writeFieldEnd()
17895 
    oprot.writeFieldStop()
17896 
    oprot.writeStructEnd()
17897 
 
17898 
  def validate(self):
17899 
    return
17900 
 
17901 
 
17902 
  def __repr__(self):
17903 
    L = ['%s=%r' % (key, value)
17904 
      for key, value in self.__dict__.iteritems()]
17905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17906 
 
17907 
  def __eq__(self, other):
17908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17909 
 
17910 
  def __ne__(self, other):
17911 
    return not (self == other)
17912 
 
17913 
class markOrderDoaRequestReceived_result:
17914 
  """
17915 
  Attributes:
17916 
   - success
17917 
   - ex
17918 
  """
17919 
 
17920 
  thrift_spec = (
17921 
    (0, TType.BOOL, 'success', None, None, ), # 0
17922 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17923 
  )
17924 
 
17925 
  def __init__(self, success=None, ex=None,):
17926 
    self.success = success
17927 
    self.ex = ex
17928 
 
17929 
  def read(self, iprot):
17930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17932 
      return
17933 
    iprot.readStructBegin()
17934 
    while True:
17935 
      (fname, ftype, fid) = iprot.readFieldBegin()
17936 
      if ftype == TType.STOP:
17937 
        break
17938 
      if fid == 0:
17939 
        if ftype == TType.BOOL:
17940 
          self.success = iprot.readBool();
17941 
        else:
17942 
          iprot.skip(ftype)
17943 
      elif fid == 1:
17944 
        if ftype == TType.STRUCT:
17945 
          self.ex = TransactionServiceException()
17946 
          self.ex.read(iprot)
17947 
        else:
17948 
          iprot.skip(ftype)
17949 
      else:
17950 
        iprot.skip(ftype)
17951 
      iprot.readFieldEnd()
17952 
    iprot.readStructEnd()
17953 
 
17954 
  def write(self, oprot):
17955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17957 
      return
17958 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17959 
    if self.success is not None:
17960 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17961 
      oprot.writeBool(self.success)
17962 
      oprot.writeFieldEnd()
17963 
    if self.ex is not None:
17964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17965 
      self.ex.write(oprot)
17966 
      oprot.writeFieldEnd()
17967 
    oprot.writeFieldStop()
17968 
    oprot.writeStructEnd()
17969 
 
17970 
  def validate(self):
17971 
    return
17972 
 
17973 
 
17974 
  def __repr__(self):
17975 
    L = ['%s=%r' % (key, value)
17976 
      for key, value in self.__dict__.iteritems()]
17977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17978 
 
17979 
  def __eq__(self, other):
17980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17981 
 
17982 
  def __ne__(self, other):
17983 
    return not (self == other)
17984 
 
17985 
class markOrderDoaRequestAuthorized_args:
17986 
  """
17987 
  Attributes:
17988 
   - orderId
17989 
   - isAuthorized
17990 
  """
17991 
 
17992 
  thrift_spec = (
17993 
    None, # 0
17994 
    (1, TType.I64, 'orderId', None, None, ), # 1
17995 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17996 
  )
17997 
 
17998 
  def __init__(self, orderId=None, isAuthorized=None,):
17999 
    self.orderId = orderId
18000 
    self.isAuthorized = isAuthorized
18001 
 
18002 
  def read(self, iprot):
18003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18005 
      return
18006 
    iprot.readStructBegin()
18007 
    while True:
18008 
      (fname, ftype, fid) = iprot.readFieldBegin()
18009 
      if ftype == TType.STOP:
18010 
        break
18011 
      if fid == 1:
18012 
        if ftype == TType.I64:
18013 
          self.orderId = iprot.readI64();
18014 
        else:
18015 
          iprot.skip(ftype)
18016 
      elif fid == 2:
18017 
        if ftype == TType.BOOL:
18018 
          self.isAuthorized = iprot.readBool();
18019 
        else:
18020 
          iprot.skip(ftype)
18021 
      else:
18022 
        iprot.skip(ftype)
18023 
      iprot.readFieldEnd()
18024 
    iprot.readStructEnd()
18025 
 
18026 
  def write(self, oprot):
18027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18029 
      return
18030 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
18031 
    if self.orderId is not None:
18032 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18033 
      oprot.writeI64(self.orderId)
18034 
      oprot.writeFieldEnd()
18035 
    if self.isAuthorized is not None:
18036 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
18037 
      oprot.writeBool(self.isAuthorized)
18038 
      oprot.writeFieldEnd()
18039 
    oprot.writeFieldStop()
18040 
    oprot.writeStructEnd()
18041 
 
18042 
  def validate(self):
18043 
    return
18044 
 
18045 
 
18046 
  def __repr__(self):
18047 
    L = ['%s=%r' % (key, value)
18048 
      for key, value in self.__dict__.iteritems()]
18049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18050 
 
18051 
  def __eq__(self, other):
18052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18053 
 
18054 
  def __ne__(self, other):
18055 
    return not (self == other)
18056 
 
18057 
class markOrderDoaRequestAuthorized_result:
18058 
  """
18059 
  Attributes:
18060 
   - success
18061 
   - ex
18062 
  """
18063 
 
18064 
  thrift_spec = (
18065 
    (0, TType.BOOL, 'success', None, None, ), # 0
18066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18067 
  )
18068 
 
18069 
  def __init__(self, success=None, ex=None,):
18070 
    self.success = success
18071 
    self.ex = ex
18072 
 
18073 
  def read(self, iprot):
18074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18076 
      return
18077 
    iprot.readStructBegin()
18078 
    while True:
18079 
      (fname, ftype, fid) = iprot.readFieldBegin()
18080 
      if ftype == TType.STOP:
18081 
        break
18082 
      if fid == 0:
18083 
        if ftype == TType.BOOL:
18084 
          self.success = iprot.readBool();
18085 
        else:
18086 
          iprot.skip(ftype)
18087 
      elif fid == 1:
18088 
        if ftype == TType.STRUCT:
18089 
          self.ex = TransactionServiceException()
18090 
          self.ex.read(iprot)
18091 
        else:
18092 
          iprot.skip(ftype)
18093 
      else:
18094 
        iprot.skip(ftype)
18095 
      iprot.readFieldEnd()
18096 
    iprot.readStructEnd()
18097 
 
18098 
  def write(self, oprot):
18099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18101 
      return
18102 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
18103 
    if self.success is not None:
18104 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18105 
      oprot.writeBool(self.success)
18106 
      oprot.writeFieldEnd()
18107 
    if self.ex is not None:
18108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18109 
      self.ex.write(oprot)
18110 
      oprot.writeFieldEnd()
18111 
    oprot.writeFieldStop()
18112 
    oprot.writeStructEnd()
18113 
 
18114 
  def validate(self):
18115 
    return
18116 
 
18117 
 
18118 
  def __repr__(self):
18119 
    L = ['%s=%r' % (key, value)
18120 
      for key, value in self.__dict__.iteritems()]
18121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18122 
 
18123 
  def __eq__(self, other):
18124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18125 
 
18126 
  def __ne__(self, other):
18127 
    return not (self == other)
18128 
 
4488 rajveer 18129 
class markOrderReturnRequestReceived_args:
18130 
  """
18131 
  Attributes:
18132 
   - orderId
18133 
  """
18134 
 
18135 
  thrift_spec = (
18136 
    None, # 0
18137 
    (1, TType.I64, 'orderId', None, None, ), # 1
18138 
  )
18139 
 
18140 
  def __init__(self, orderId=None,):
18141 
    self.orderId = orderId
18142 
 
18143 
  def read(self, iprot):
18144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18146 
      return
18147 
    iprot.readStructBegin()
18148 
    while True:
18149 
      (fname, ftype, fid) = iprot.readFieldBegin()
18150 
      if ftype == TType.STOP:
18151 
        break
18152 
      if fid == 1:
18153 
        if ftype == TType.I64:
18154 
          self.orderId = iprot.readI64();
18155 
        else:
18156 
          iprot.skip(ftype)
18157 
      else:
18158 
        iprot.skip(ftype)
18159 
      iprot.readFieldEnd()
18160 
    iprot.readStructEnd()
18161 
 
18162 
  def write(self, oprot):
18163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18165 
      return
18166 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
18167 
    if self.orderId is not None:
18168 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18169 
      oprot.writeI64(self.orderId)
18170 
      oprot.writeFieldEnd()
18171 
    oprot.writeFieldStop()
18172 
    oprot.writeStructEnd()
18173 
 
18174 
  def validate(self):
18175 
    return
18176 
 
18177 
 
18178 
  def __repr__(self):
18179 
    L = ['%s=%r' % (key, value)
18180 
      for key, value in self.__dict__.iteritems()]
18181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18182 
 
18183 
  def __eq__(self, other):
18184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18185 
 
18186 
  def __ne__(self, other):
18187 
    return not (self == other)
18188 
 
18189 
class markOrderReturnRequestReceived_result:
18190 
  """
18191 
  Attributes:
18192 
   - success
18193 
   - ex
18194 
  """
18195 
 
18196 
  thrift_spec = (
18197 
    (0, TType.BOOL, 'success', None, None, ), # 0
18198 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18199 
  )
18200 
 
18201 
  def __init__(self, success=None, ex=None,):
18202 
    self.success = success
18203 
    self.ex = ex
18204 
 
18205 
  def read(self, iprot):
18206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18208 
      return
18209 
    iprot.readStructBegin()
18210 
    while True:
18211 
      (fname, ftype, fid) = iprot.readFieldBegin()
18212 
      if ftype == TType.STOP:
18213 
        break
18214 
      if fid == 0:
18215 
        if ftype == TType.BOOL:
18216 
          self.success = iprot.readBool();
18217 
        else:
18218 
          iprot.skip(ftype)
18219 
      elif fid == 1:
18220 
        if ftype == TType.STRUCT:
18221 
          self.ex = TransactionServiceException()
18222 
          self.ex.read(iprot)
18223 
        else:
18224 
          iprot.skip(ftype)
18225 
      else:
18226 
        iprot.skip(ftype)
18227 
      iprot.readFieldEnd()
18228 
    iprot.readStructEnd()
18229 
 
18230 
  def write(self, oprot):
18231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18233 
      return
18234 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
18235 
    if self.success is not None:
18236 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18237 
      oprot.writeBool(self.success)
18238 
      oprot.writeFieldEnd()
18239 
    if self.ex is not None:
18240 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18241 
      self.ex.write(oprot)
18242 
      oprot.writeFieldEnd()
18243 
    oprot.writeFieldStop()
18244 
    oprot.writeStructEnd()
18245 
 
18246 
  def validate(self):
18247 
    return
18248 
 
18249 
 
18250 
  def __repr__(self):
18251 
    L = ['%s=%r' % (key, value)
18252 
      for key, value in self.__dict__.iteritems()]
18253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18254 
 
18255 
  def __eq__(self, other):
18256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18257 
 
18258 
  def __ne__(self, other):
18259 
    return not (self == other)
18260 
 
18261 
class markOrderReturnRequestAuthorized_args:
18262 
  """
18263 
  Attributes:
18264 
   - orderId
18265 
   - isAuthorized
18266 
  """
18267 
 
18268 
  thrift_spec = (
18269 
    None, # 0
18270 
    (1, TType.I64, 'orderId', None, None, ), # 1
18271 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
18272 
  )
18273 
 
18274 
  def __init__(self, orderId=None, isAuthorized=None,):
18275 
    self.orderId = orderId
18276 
    self.isAuthorized = isAuthorized
18277 
 
18278 
  def read(self, iprot):
18279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18281 
      return
18282 
    iprot.readStructBegin()
18283 
    while True:
18284 
      (fname, ftype, fid) = iprot.readFieldBegin()
18285 
      if ftype == TType.STOP:
18286 
        break
18287 
      if fid == 1:
18288 
        if ftype == TType.I64:
18289 
          self.orderId = iprot.readI64();
18290 
        else:
18291 
          iprot.skip(ftype)
18292 
      elif fid == 2:
18293 
        if ftype == TType.BOOL:
18294 
          self.isAuthorized = iprot.readBool();
18295 
        else:
18296 
          iprot.skip(ftype)
18297 
      else:
18298 
        iprot.skip(ftype)
18299 
      iprot.readFieldEnd()
18300 
    iprot.readStructEnd()
18301 
 
18302 
  def write(self, oprot):
18303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18305 
      return
18306 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
18307 
    if self.orderId is not None:
18308 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18309 
      oprot.writeI64(self.orderId)
18310 
      oprot.writeFieldEnd()
18311 
    if self.isAuthorized is not None:
18312 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
18313 
      oprot.writeBool(self.isAuthorized)
18314 
      oprot.writeFieldEnd()
18315 
    oprot.writeFieldStop()
18316 
    oprot.writeStructEnd()
18317 
 
18318 
  def validate(self):
18319 
    return
18320 
 
18321 
 
18322 
  def __repr__(self):
18323 
    L = ['%s=%r' % (key, value)
18324 
      for key, value in self.__dict__.iteritems()]
18325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18326 
 
18327 
  def __eq__(self, other):
18328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18329 
 
18330 
  def __ne__(self, other):
18331 
    return not (self == other)
18332 
 
18333 
class markOrderReturnRequestAuthorized_result:
18334 
  """
18335 
  Attributes:
18336 
   - success
18337 
   - ex
18338 
  """
18339 
 
18340 
  thrift_spec = (
18341 
    (0, TType.BOOL, 'success', None, None, ), # 0
18342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18343 
  )
18344 
 
18345 
  def __init__(self, success=None, ex=None,):
18346 
    self.success = success
18347 
    self.ex = ex
18348 
 
18349 
  def read(self, iprot):
18350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18352 
      return
18353 
    iprot.readStructBegin()
18354 
    while True:
18355 
      (fname, ftype, fid) = iprot.readFieldBegin()
18356 
      if ftype == TType.STOP:
18357 
        break
18358 
      if fid == 0:
18359 
        if ftype == TType.BOOL:
18360 
          self.success = iprot.readBool();
18361 
        else:
18362 
          iprot.skip(ftype)
18363 
      elif fid == 1:
18364 
        if ftype == TType.STRUCT:
18365 
          self.ex = TransactionServiceException()
18366 
          self.ex.read(iprot)
18367 
        else:
18368 
          iprot.skip(ftype)
18369 
      else:
18370 
        iprot.skip(ftype)
18371 
      iprot.readFieldEnd()
18372 
    iprot.readStructEnd()
18373 
 
18374 
  def write(self, oprot):
18375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18377 
      return
18378 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
18379 
    if self.success is not None:
18380 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18381 
      oprot.writeBool(self.success)
18382 
      oprot.writeFieldEnd()
18383 
    if self.ex is not None:
18384 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18385 
      self.ex.write(oprot)
18386 
      oprot.writeFieldEnd()
18387 
    oprot.writeFieldStop()
18388 
    oprot.writeStructEnd()
18389 
 
18390 
  def validate(self):
18391 
    return
18392 
 
18393 
 
18394 
  def __repr__(self):
18395 
    L = ['%s=%r' % (key, value)
18396 
      for key, value in self.__dict__.iteritems()]
18397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18398 
 
18399 
  def __eq__(self, other):
18400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18401 
 
18402 
  def __ne__(self, other):
18403 
    return not (self == other)
18404 
 
2536 chandransh 18405 
class requestPickupNumber_args:
18406 
  """
18407 
  Attributes:
18408 
   - orderId
4579 rajveer 18409 
   - providerId
2536 chandransh 18410 
  """
18411 
 
18412 
  thrift_spec = (
18413 
    None, # 0
18414 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 18415 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 18416 
  )
18417 
 
4579 rajveer 18418 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 18419 
    self.orderId = orderId
4579 rajveer 18420 
    self.providerId = providerId
2536 chandransh 18421 
 
18422 
  def read(self, iprot):
18423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18425 
      return
18426 
    iprot.readStructBegin()
18427 
    while True:
18428 
      (fname, ftype, fid) = iprot.readFieldBegin()
18429 
      if ftype == TType.STOP:
18430 
        break
18431 
      if fid == 1:
18432 
        if ftype == TType.I64:
18433 
          self.orderId = iprot.readI64();
18434 
        else:
18435 
          iprot.skip(ftype)
4579 rajveer 18436 
      elif fid == 2:
18437 
        if ftype == TType.I64:
18438 
          self.providerId = iprot.readI64();
18439 
        else:
18440 
          iprot.skip(ftype)
2536 chandransh 18441 
      else:
18442 
        iprot.skip(ftype)
18443 
      iprot.readFieldEnd()
18444 
    iprot.readStructEnd()
18445 
 
18446 
  def write(self, oprot):
18447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18449 
      return
18450 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 18451 
    if self.orderId is not None:
2536 chandransh 18452 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18453 
      oprot.writeI64(self.orderId)
18454 
      oprot.writeFieldEnd()
4579 rajveer 18455 
    if self.providerId is not None:
18456 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
18457 
      oprot.writeI64(self.providerId)
18458 
      oprot.writeFieldEnd()
2536 chandransh 18459 
    oprot.writeFieldStop()
18460 
    oprot.writeStructEnd()
18461 
 
3431 rajveer 18462 
  def validate(self):
18463 
    return
18464 
 
18465 
 
2536 chandransh 18466 
  def __repr__(self):
18467 
    L = ['%s=%r' % (key, value)
18468 
      for key, value in self.__dict__.iteritems()]
18469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18470 
 
18471 
  def __eq__(self, other):
18472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18473 
 
18474 
  def __ne__(self, other):
18475 
    return not (self == other)
18476 
 
18477 
class requestPickupNumber_result:
18478 
  """
18479 
  Attributes:
18480 
   - success
18481 
   - ex
18482 
  """
18483 
 
18484 
  thrift_spec = (
18485 
    (0, TType.BOOL, 'success', None, None, ), # 0
18486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18487 
  )
18488 
 
18489 
  def __init__(self, success=None, ex=None,):
18490 
    self.success = success
18491 
    self.ex = ex
18492 
 
18493 
  def read(self, iprot):
18494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18496 
      return
18497 
    iprot.readStructBegin()
18498 
    while True:
18499 
      (fname, ftype, fid) = iprot.readFieldBegin()
18500 
      if ftype == TType.STOP:
18501 
        break
18502 
      if fid == 0:
18503 
        if ftype == TType.BOOL:
18504 
          self.success = iprot.readBool();
18505 
        else:
18506 
          iprot.skip(ftype)
18507 
      elif fid == 1:
18508 
        if ftype == TType.STRUCT:
18509 
          self.ex = TransactionServiceException()
18510 
          self.ex.read(iprot)
18511 
        else:
18512 
          iprot.skip(ftype)
18513 
      else:
18514 
        iprot.skip(ftype)
18515 
      iprot.readFieldEnd()
18516 
    iprot.readStructEnd()
18517 
 
18518 
  def write(self, oprot):
18519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18521 
      return
18522 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 18523 
    if self.success is not None:
2536 chandransh 18524 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18525 
      oprot.writeBool(self.success)
18526 
      oprot.writeFieldEnd()
3431 rajveer 18527 
    if self.ex is not None:
2536 chandransh 18528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18529 
      self.ex.write(oprot)
18530 
      oprot.writeFieldEnd()
18531 
    oprot.writeFieldStop()
18532 
    oprot.writeStructEnd()
18533 
 
3431 rajveer 18534 
  def validate(self):
18535 
    return
18536 
 
18537 
 
2536 chandransh 18538 
  def __repr__(self):
18539 
    L = ['%s=%r' % (key, value)
18540 
      for key, value in self.__dict__.iteritems()]
18541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18542 
 
18543 
  def __eq__(self, other):
18544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18545 
 
18546 
  def __ne__(self, other):
18547 
    return not (self == other)
18548 
 
18549 
class authorizePickup_args:
18550 
  """
18551 
  Attributes:
18552 
   - orderId
18553 
   - pickupNumber
4602 rajveer 18554 
   - providerId
2536 chandransh 18555 
  """
18556 
 
18557 
  thrift_spec = (
18558 
    None, # 0
18559 
    (1, TType.I64, 'orderId', None, None, ), # 1
18560 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 18561 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 18562 
  )
18563 
 
4602 rajveer 18564 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 18565 
    self.orderId = orderId
18566 
    self.pickupNumber = pickupNumber
4602 rajveer 18567 
    self.providerId = providerId
2536 chandransh 18568 
 
18569 
  def read(self, iprot):
18570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18572 
      return
18573 
    iprot.readStructBegin()
18574 
    while True:
18575 
      (fname, ftype, fid) = iprot.readFieldBegin()
18576 
      if ftype == TType.STOP:
18577 
        break
18578 
      if fid == 1:
18579 
        if ftype == TType.I64:
18580 
          self.orderId = iprot.readI64();
18581 
        else:
18582 
          iprot.skip(ftype)
18583 
      elif fid == 2:
18584 
        if ftype == TType.STRING:
18585 
          self.pickupNumber = iprot.readString();
18586 
        else:
18587 
          iprot.skip(ftype)
4602 rajveer 18588 
      elif fid == 3:
18589 
        if ftype == TType.I64:
18590 
          self.providerId = iprot.readI64();
18591 
        else:
18592 
          iprot.skip(ftype)
2536 chandransh 18593 
      else:
18594 
        iprot.skip(ftype)
18595 
      iprot.readFieldEnd()
18596 
    iprot.readStructEnd()
18597 
 
18598 
  def write(self, oprot):
18599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18601 
      return
18602 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 18603 
    if self.orderId is not None:
2536 chandransh 18604 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18605 
      oprot.writeI64(self.orderId)
18606 
      oprot.writeFieldEnd()
3431 rajveer 18607 
    if self.pickupNumber is not None:
2536 chandransh 18608 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
18609 
      oprot.writeString(self.pickupNumber)
18610 
      oprot.writeFieldEnd()
4602 rajveer 18611 
    if self.providerId is not None:
18612 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
18613 
      oprot.writeI64(self.providerId)
18614 
      oprot.writeFieldEnd()
2536 chandransh 18615 
    oprot.writeFieldStop()
18616 
    oprot.writeStructEnd()
18617 
 
3431 rajveer 18618 
  def validate(self):
18619 
    return
18620 
 
18621 
 
2536 chandransh 18622 
  def __repr__(self):
18623 
    L = ['%s=%r' % (key, value)
18624 
      for key, value in self.__dict__.iteritems()]
18625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18626 
 
18627 
  def __eq__(self, other):
18628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18629 
 
18630 
  def __ne__(self, other):
18631 
    return not (self == other)
18632 
 
18633 
class authorizePickup_result:
18634 
  """
18635 
  Attributes:
18636 
   - success
18637 
   - ex
18638 
  """
18639 
 
18640 
  thrift_spec = (
18641 
    (0, TType.BOOL, 'success', None, None, ), # 0
18642 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18643 
  )
18644 
 
18645 
  def __init__(self, success=None, ex=None,):
18646 
    self.success = success
18647 
    self.ex = ex
18648 
 
18649 
  def read(self, iprot):
18650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18652 
      return
18653 
    iprot.readStructBegin()
18654 
    while True:
18655 
      (fname, ftype, fid) = iprot.readFieldBegin()
18656 
      if ftype == TType.STOP:
18657 
        break
18658 
      if fid == 0:
18659 
        if ftype == TType.BOOL:
18660 
          self.success = iprot.readBool();
18661 
        else:
18662 
          iprot.skip(ftype)
18663 
      elif fid == 1:
18664 
        if ftype == TType.STRUCT:
18665 
          self.ex = TransactionServiceException()
18666 
          self.ex.read(iprot)
18667 
        else:
18668 
          iprot.skip(ftype)
18669 
      else:
18670 
        iprot.skip(ftype)
18671 
      iprot.readFieldEnd()
18672 
    iprot.readStructEnd()
18673 
 
18674 
  def write(self, oprot):
18675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18677 
      return
18678 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18679 
    if self.success is not None:
2536 chandransh 18680 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18681 
      oprot.writeBool(self.success)
18682 
      oprot.writeFieldEnd()
3431 rajveer 18683 
    if self.ex is not None:
2536 chandransh 18684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18685 
      self.ex.write(oprot)
18686 
      oprot.writeFieldEnd()
18687 
    oprot.writeFieldStop()
18688 
    oprot.writeStructEnd()
18689 
 
3431 rajveer 18690 
  def validate(self):
18691 
    return
18692 
 
18693 
 
2536 chandransh 18694 
  def __repr__(self):
18695 
    L = ['%s=%r' % (key, value)
18696 
      for key, value in self.__dict__.iteritems()]
18697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18698 
 
18699 
  def __eq__(self, other):
18700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18701 
 
18702 
  def __ne__(self, other):
18703 
    return not (self == other)
18704 
 
2764 chandransh 18705 
class markDoasAsPickedUp_args:
18706 
  """
18707 
  Attributes:
18708 
   - providerId
18709 
   - pickupDetails
18710 
  """
18711 
 
18712 
  thrift_spec = (
18713 
    None, # 0
18714 
    (1, TType.I64, 'providerId', None, None, ), # 1
18715 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18716 
  )
18717 
 
18718 
  def __init__(self, providerId=None, pickupDetails=None,):
18719 
    self.providerId = providerId
18720 
    self.pickupDetails = pickupDetails
18721 
 
18722 
  def read(self, iprot):
18723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18725 
      return
18726 
    iprot.readStructBegin()
18727 
    while True:
18728 
      (fname, ftype, fid) = iprot.readFieldBegin()
18729 
      if ftype == TType.STOP:
18730 
        break
18731 
      if fid == 1:
18732 
        if ftype == TType.I64:
18733 
          self.providerId = iprot.readI64();
18734 
        else:
18735 
          iprot.skip(ftype)
18736 
      elif fid == 2:
18737 
        if ftype == TType.MAP:
18738 
          self.pickupDetails = {}
6188 rajveer 18739 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18740 
          for _i411 in xrange(_size407):
18741 
            _key412 = iprot.readString();
18742 
            _val413 = iprot.readString();
18743 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18744 
          iprot.readMapEnd()
18745 
        else:
18746 
          iprot.skip(ftype)
18747 
      else:
18748 
        iprot.skip(ftype)
18749 
      iprot.readFieldEnd()
18750 
    iprot.readStructEnd()
18751 
 
18752 
  def write(self, oprot):
18753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18755 
      return
18756 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18757 
    if self.providerId is not None:
2764 chandransh 18758 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18759 
      oprot.writeI64(self.providerId)
18760 
      oprot.writeFieldEnd()
3431 rajveer 18761 
    if self.pickupDetails is not None:
2764 chandransh 18762 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18763 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18764 
      for kiter414,viter415 in self.pickupDetails.items():
18765 
        oprot.writeString(kiter414)
18766 
        oprot.writeString(viter415)
2764 chandransh 18767 
      oprot.writeMapEnd()
18768 
      oprot.writeFieldEnd()
18769 
    oprot.writeFieldStop()
18770 
    oprot.writeStructEnd()
18771 
 
3431 rajveer 18772 
  def validate(self):
18773 
    return
18774 
 
18775 
 
2764 chandransh 18776 
  def __repr__(self):
18777 
    L = ['%s=%r' % (key, value)
18778 
      for key, value in self.__dict__.iteritems()]
18779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18780 
 
18781 
  def __eq__(self, other):
18782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18783 
 
18784 
  def __ne__(self, other):
18785 
    return not (self == other)
18786 
 
18787 
class markDoasAsPickedUp_result:
4910 phani.kuma 18788 
 
18789 
  thrift_spec = (
18790 
  )
18791 
 
18792 
  def read(self, iprot):
18793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18795 
      return
18796 
    iprot.readStructBegin()
18797 
    while True:
18798 
      (fname, ftype, fid) = iprot.readFieldBegin()
18799 
      if ftype == TType.STOP:
18800 
        break
18801 
      else:
18802 
        iprot.skip(ftype)
18803 
      iprot.readFieldEnd()
18804 
    iprot.readStructEnd()
18805 
 
18806 
  def write(self, oprot):
18807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18809 
      return
18810 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18811 
    oprot.writeFieldStop()
18812 
    oprot.writeStructEnd()
18813 
 
18814 
  def validate(self):
18815 
    return
18816 
 
18817 
 
18818 
  def __repr__(self):
18819 
    L = ['%s=%r' % (key, value)
18820 
      for key, value in self.__dict__.iteritems()]
18821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18822 
 
18823 
  def __eq__(self, other):
18824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18825 
 
18826 
  def __ne__(self, other):
18827 
    return not (self == other)
18828 
 
18829 
class getDoasNotPickedUp_args:
2764 chandransh 18830 
  """
18831 
  Attributes:
4910 phani.kuma 18832 
   - providerId
18833 
  """
18834 
 
18835 
  thrift_spec = (
18836 
    None, # 0
18837 
    (1, TType.I64, 'providerId', None, None, ), # 1
18838 
  )
18839 
 
18840 
  def __init__(self, providerId=None,):
18841 
    self.providerId = providerId
18842 
 
18843 
  def read(self, iprot):
18844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18846 
      return
18847 
    iprot.readStructBegin()
18848 
    while True:
18849 
      (fname, ftype, fid) = iprot.readFieldBegin()
18850 
      if ftype == TType.STOP:
18851 
        break
18852 
      if fid == 1:
18853 
        if ftype == TType.I64:
18854 
          self.providerId = iprot.readI64();
18855 
        else:
18856 
          iprot.skip(ftype)
18857 
      else:
18858 
        iprot.skip(ftype)
18859 
      iprot.readFieldEnd()
18860 
    iprot.readStructEnd()
18861 
 
18862 
  def write(self, oprot):
18863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18865 
      return
18866 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18867 
    if self.providerId is not None:
18868 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18869 
      oprot.writeI64(self.providerId)
18870 
      oprot.writeFieldEnd()
18871 
    oprot.writeFieldStop()
18872 
    oprot.writeStructEnd()
18873 
 
18874 
  def validate(self):
18875 
    return
18876 
 
18877 
 
18878 
  def __repr__(self):
18879 
    L = ['%s=%r' % (key, value)
18880 
      for key, value in self.__dict__.iteritems()]
18881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18882 
 
18883 
  def __eq__(self, other):
18884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18885 
 
18886 
  def __ne__(self, other):
18887 
    return not (self == other)
18888 
 
18889 
class getDoasNotPickedUp_result:
18890 
  """
18891 
  Attributes:
2764 chandransh 18892 
   - success
18893 
  """
18894 
 
18895 
  thrift_spec = (
18896 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18897 
  )
18898 
 
18899 
  def __init__(self, success=None,):
18900 
    self.success = success
18901 
 
18902 
  def read(self, iprot):
18903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18905 
      return
18906 
    iprot.readStructBegin()
18907 
    while True:
18908 
      (fname, ftype, fid) = iprot.readFieldBegin()
18909 
      if ftype == TType.STOP:
18910 
        break
18911 
      if fid == 0:
18912 
        if ftype == TType.LIST:
18913 
          self.success = []
6188 rajveer 18914 
          (_etype419, _size416) = iprot.readListBegin()
18915 
          for _i420 in xrange(_size416):
18916 
            _elem421 = Order()
18917 
            _elem421.read(iprot)
18918 
            self.success.append(_elem421)
2764 chandransh 18919 
          iprot.readListEnd()
18920 
        else:
18921 
          iprot.skip(ftype)
18922 
      else:
18923 
        iprot.skip(ftype)
18924 
      iprot.readFieldEnd()
18925 
    iprot.readStructEnd()
18926 
 
18927 
  def write(self, oprot):
18928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18930 
      return
4910 phani.kuma 18931 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18932 
    if self.success is not None:
2764 chandransh 18933 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18934 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18935 
      for iter422 in self.success:
18936 
        iter422.write(oprot)
2764 chandransh 18937 
      oprot.writeListEnd()
18938 
      oprot.writeFieldEnd()
18939 
    oprot.writeFieldStop()
18940 
    oprot.writeStructEnd()
18941 
 
3431 rajveer 18942 
  def validate(self):
18943 
    return
18944 
 
18945 
 
2764 chandransh 18946 
  def __repr__(self):
18947 
    L = ['%s=%r' % (key, value)
18948 
      for key, value in self.__dict__.iteritems()]
18949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18950 
 
18951 
  def __eq__(self, other):
18952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18953 
 
18954 
  def __ne__(self, other):
18955 
    return not (self == other)
18956 
 
4741 phani.kuma 18957 
class markReturnOrdersAsPickedUp_args:
18958 
  """
18959 
  Attributes:
18960 
   - providerId
18961 
   - pickupDetails
18962 
  """
18963 
 
18964 
  thrift_spec = (
18965 
    None, # 0
18966 
    (1, TType.I64, 'providerId', None, None, ), # 1
18967 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18968 
  )
18969 
 
18970 
  def __init__(self, providerId=None, pickupDetails=None,):
18971 
    self.providerId = providerId
18972 
    self.pickupDetails = pickupDetails
18973 
 
18974 
  def read(self, iprot):
18975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18977 
      return
18978 
    iprot.readStructBegin()
18979 
    while True:
18980 
      (fname, ftype, fid) = iprot.readFieldBegin()
18981 
      if ftype == TType.STOP:
18982 
        break
18983 
      if fid == 1:
18984 
        if ftype == TType.I64:
18985 
          self.providerId = iprot.readI64();
18986 
        else:
18987 
          iprot.skip(ftype)
18988 
      elif fid == 2:
18989 
        if ftype == TType.MAP:
18990 
          self.pickupDetails = {}
6188 rajveer 18991 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18992 
          for _i427 in xrange(_size423):
18993 
            _key428 = iprot.readString();
18994 
            _val429 = iprot.readString();
18995 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18996 
          iprot.readMapEnd()
18997 
        else:
18998 
          iprot.skip(ftype)
18999 
      else:
19000 
        iprot.skip(ftype)
19001 
      iprot.readFieldEnd()
19002 
    iprot.readStructEnd()
19003 
 
19004 
  def write(self, oprot):
19005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19007 
      return
19008 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
19009 
    if self.providerId is not None:
19010 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
19011 
      oprot.writeI64(self.providerId)
19012 
      oprot.writeFieldEnd()
19013 
    if self.pickupDetails is not None:
19014 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
19015 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 19016 
      for kiter430,viter431 in self.pickupDetails.items():
19017 
        oprot.writeString(kiter430)
19018 
        oprot.writeString(viter431)
4741 phani.kuma 19019 
      oprot.writeMapEnd()
19020 
      oprot.writeFieldEnd()
19021 
    oprot.writeFieldStop()
19022 
    oprot.writeStructEnd()
19023 
 
19024 
  def validate(self):
19025 
    return
19026 
 
19027 
 
19028 
  def __repr__(self):
19029 
    L = ['%s=%r' % (key, value)
19030 
      for key, value in self.__dict__.iteritems()]
19031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19032 
 
19033 
  def __eq__(self, other):
19034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19035 
 
19036 
  def __ne__(self, other):
19037 
    return not (self == other)
19038 
 
19039 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 19040 
 
19041 
  thrift_spec = (
19042 
  )
19043 
 
19044 
  def read(self, iprot):
19045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19047 
      return
19048 
    iprot.readStructBegin()
19049 
    while True:
19050 
      (fname, ftype, fid) = iprot.readFieldBegin()
19051 
      if ftype == TType.STOP:
19052 
        break
19053 
      else:
19054 
        iprot.skip(ftype)
19055 
      iprot.readFieldEnd()
19056 
    iprot.readStructEnd()
19057 
 
19058 
  def write(self, oprot):
19059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19061 
      return
19062 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
19063 
    oprot.writeFieldStop()
19064 
    oprot.writeStructEnd()
19065 
 
19066 
  def validate(self):
19067 
    return
19068 
 
19069 
 
19070 
  def __repr__(self):
19071 
    L = ['%s=%r' % (key, value)
19072 
      for key, value in self.__dict__.iteritems()]
19073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19074 
 
19075 
  def __eq__(self, other):
19076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19077 
 
19078 
  def __ne__(self, other):
19079 
    return not (self == other)
19080 
 
19081 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 19082 
  """
19083 
  Attributes:
4910 phani.kuma 19084 
   - providerId
19085 
  """
19086 
 
19087 
  thrift_spec = (
19088 
    None, # 0
19089 
    (1, TType.I64, 'providerId', None, None, ), # 1
19090 
  )
19091 
 
19092 
  def __init__(self, providerId=None,):
19093 
    self.providerId = providerId
19094 
 
19095 
  def read(self, iprot):
19096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19098 
      return
19099 
    iprot.readStructBegin()
19100 
    while True:
19101 
      (fname, ftype, fid) = iprot.readFieldBegin()
19102 
      if ftype == TType.STOP:
19103 
        break
19104 
      if fid == 1:
19105 
        if ftype == TType.I64:
19106 
          self.providerId = iprot.readI64();
19107 
        else:
19108 
          iprot.skip(ftype)
19109 
      else:
19110 
        iprot.skip(ftype)
19111 
      iprot.readFieldEnd()
19112 
    iprot.readStructEnd()
19113 
 
19114 
  def write(self, oprot):
19115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19117 
      return
19118 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
19119 
    if self.providerId is not None:
19120 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
19121 
      oprot.writeI64(self.providerId)
19122 
      oprot.writeFieldEnd()
19123 
    oprot.writeFieldStop()
19124 
    oprot.writeStructEnd()
19125 
 
19126 
  def validate(self):
19127 
    return
19128 
 
19129 
 
19130 
  def __repr__(self):
19131 
    L = ['%s=%r' % (key, value)
19132 
      for key, value in self.__dict__.iteritems()]
19133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19134 
 
19135 
  def __eq__(self, other):
19136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19137 
 
19138 
  def __ne__(self, other):
19139 
    return not (self == other)
19140 
 
19141 
class getReturnOrdersNotPickedUp_result:
19142 
  """
19143 
  Attributes:
4741 phani.kuma 19144 
   - success
19145 
  """
19146 
 
19147 
  thrift_spec = (
19148 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19149 
  )
19150 
 
19151 
  def __init__(self, success=None,):
19152 
    self.success = success
19153 
 
19154 
  def read(self, iprot):
19155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19157 
      return
19158 
    iprot.readStructBegin()
19159 
    while True:
19160 
      (fname, ftype, fid) = iprot.readFieldBegin()
19161 
      if ftype == TType.STOP:
19162 
        break
19163 
      if fid == 0:
19164 
        if ftype == TType.LIST:
19165 
          self.success = []
6188 rajveer 19166 
          (_etype435, _size432) = iprot.readListBegin()
19167 
          for _i436 in xrange(_size432):
19168 
            _elem437 = Order()
19169 
            _elem437.read(iprot)
19170 
            self.success.append(_elem437)
4741 phani.kuma 19171 
          iprot.readListEnd()
19172 
        else:
19173 
          iprot.skip(ftype)
19174 
      else:
19175 
        iprot.skip(ftype)
19176 
      iprot.readFieldEnd()
19177 
    iprot.readStructEnd()
19178 
 
19179 
  def write(self, oprot):
19180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19182 
      return
4910 phani.kuma 19183 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 19184 
    if self.success is not None:
19185 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19186 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19187 
      for iter438 in self.success:
19188 
        iter438.write(oprot)
4741 phani.kuma 19189 
      oprot.writeListEnd()
19190 
      oprot.writeFieldEnd()
19191 
    oprot.writeFieldStop()
19192 
    oprot.writeStructEnd()
19193 
 
19194 
  def validate(self):
19195 
    return
19196 
 
19197 
 
19198 
  def __repr__(self):
19199 
    L = ['%s=%r' % (key, value)
19200 
      for key, value in self.__dict__.iteritems()]
19201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19202 
 
19203 
  def __eq__(self, other):
19204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19205 
 
19206 
  def __ne__(self, other):
19207 
    return not (self == other)
19208 
 
2616 chandransh 19209 
class receiveReturn_args:
2591 chandransh 19210 
  """
19211 
  Attributes:
19212 
   - orderId
4479 rajveer 19213 
   - receiveCondition
2591 chandransh 19214 
  """
2536 chandransh 19215 
 
2591 chandransh 19216 
  thrift_spec = (
19217 
    None, # 0
19218 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 19219 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 19220 
  )
19221 
 
4479 rajveer 19222 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 19223 
    self.orderId = orderId
4479 rajveer 19224 
    self.receiveCondition = receiveCondition
2591 chandransh 19225 
 
19226 
  def read(self, iprot):
19227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19229 
      return
19230 
    iprot.readStructBegin()
19231 
    while True:
19232 
      (fname, ftype, fid) = iprot.readFieldBegin()
19233 
      if ftype == TType.STOP:
19234 
        break
19235 
      if fid == 1:
19236 
        if ftype == TType.I64:
19237 
          self.orderId = iprot.readI64();
19238 
        else:
19239 
          iprot.skip(ftype)
4479 rajveer 19240 
      elif fid == 2:
19241 
        if ftype == TType.I64:
19242 
          self.receiveCondition = iprot.readI64();
19243 
        else:
19244 
          iprot.skip(ftype)
2591 chandransh 19245 
      else:
19246 
        iprot.skip(ftype)
19247 
      iprot.readFieldEnd()
19248 
    iprot.readStructEnd()
19249 
 
19250 
  def write(self, oprot):
19251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19253 
      return
2616 chandransh 19254 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 19255 
    if self.orderId is not None:
2591 chandransh 19256 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19257 
      oprot.writeI64(self.orderId)
19258 
      oprot.writeFieldEnd()
4479 rajveer 19259 
    if self.receiveCondition is not None:
19260 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
19261 
      oprot.writeI64(self.receiveCondition)
19262 
      oprot.writeFieldEnd()
2591 chandransh 19263 
    oprot.writeFieldStop()
19264 
    oprot.writeStructEnd()
19265 
 
3431 rajveer 19266 
  def validate(self):
19267 
    return
19268 
 
19269 
 
2591 chandransh 19270 
  def __repr__(self):
19271 
    L = ['%s=%r' % (key, value)
19272 
      for key, value in self.__dict__.iteritems()]
19273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19274 
 
19275 
  def __eq__(self, other):
19276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19277 
 
19278 
  def __ne__(self, other):
19279 
    return not (self == other)
19280 
 
2616 chandransh 19281 
class receiveReturn_result:
2591 chandransh 19282 
  """
19283 
  Attributes:
19284 
   - success
19285 
   - ex
19286 
  """
19287 
 
19288 
  thrift_spec = (
19289 
    (0, TType.BOOL, 'success', None, None, ), # 0
19290 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19291 
  )
19292 
 
19293 
  def __init__(self, success=None, ex=None,):
19294 
    self.success = success
19295 
    self.ex = ex
19296 
 
19297 
  def read(self, iprot):
19298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19300 
      return
19301 
    iprot.readStructBegin()
19302 
    while True:
19303 
      (fname, ftype, fid) = iprot.readFieldBegin()
19304 
      if ftype == TType.STOP:
19305 
        break
19306 
      if fid == 0:
19307 
        if ftype == TType.BOOL:
19308 
          self.success = iprot.readBool();
19309 
        else:
19310 
          iprot.skip(ftype)
19311 
      elif fid == 1:
19312 
        if ftype == TType.STRUCT:
19313 
          self.ex = TransactionServiceException()
19314 
          self.ex.read(iprot)
19315 
        else:
19316 
          iprot.skip(ftype)
19317 
      else:
19318 
        iprot.skip(ftype)
19319 
      iprot.readFieldEnd()
19320 
    iprot.readStructEnd()
19321 
 
19322 
  def write(self, oprot):
19323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19325 
      return
2616 chandransh 19326 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 19327 
    if self.success is not None:
2591 chandransh 19328 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19329 
      oprot.writeBool(self.success)
19330 
      oprot.writeFieldEnd()
3431 rajveer 19331 
    if self.ex is not None:
2591 chandransh 19332 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19333 
      self.ex.write(oprot)
19334 
      oprot.writeFieldEnd()
19335 
    oprot.writeFieldStop()
19336 
    oprot.writeStructEnd()
19337 
 
3431 rajveer 19338 
  def validate(self):
19339 
    return
19340 
 
19341 
 
2591 chandransh 19342 
  def __repr__(self):
19343 
    L = ['%s=%r' % (key, value)
19344 
      for key, value in self.__dict__.iteritems()]
19345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19346 
 
19347 
  def __eq__(self, other):
19348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19349 
 
19350 
  def __ne__(self, other):
19351 
    return not (self == other)
19352 
 
19353 
class validateDoa_args:
19354 
  """
19355 
  Attributes:
19356 
   - orderId
19357 
   - isValid
19358 
  """
19359 
 
19360 
  thrift_spec = (
19361 
    None, # 0
19362 
    (1, TType.I64, 'orderId', None, None, ), # 1
19363 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
19364 
  )
19365 
 
19366 
  def __init__(self, orderId=None, isValid=None,):
19367 
    self.orderId = orderId
19368 
    self.isValid = isValid
19369 
 
19370 
  def read(self, iprot):
19371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19373 
      return
19374 
    iprot.readStructBegin()
19375 
    while True:
19376 
      (fname, ftype, fid) = iprot.readFieldBegin()
19377 
      if ftype == TType.STOP:
19378 
        break
19379 
      if fid == 1:
19380 
        if ftype == TType.I64:
19381 
          self.orderId = iprot.readI64();
19382 
        else:
19383 
          iprot.skip(ftype)
19384 
      elif fid == 2:
19385 
        if ftype == TType.BOOL:
19386 
          self.isValid = iprot.readBool();
19387 
        else:
19388 
          iprot.skip(ftype)
19389 
      else:
19390 
        iprot.skip(ftype)
19391 
      iprot.readFieldEnd()
19392 
    iprot.readStructEnd()
19393 
 
19394 
  def write(self, oprot):
19395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19397 
      return
19398 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 19399 
    if self.orderId is not None:
2591 chandransh 19400 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19401 
      oprot.writeI64(self.orderId)
19402 
      oprot.writeFieldEnd()
3431 rajveer 19403 
    if self.isValid is not None:
2591 chandransh 19404 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
19405 
      oprot.writeBool(self.isValid)
19406 
      oprot.writeFieldEnd()
19407 
    oprot.writeFieldStop()
19408 
    oprot.writeStructEnd()
19409 
 
3431 rajveer 19410 
  def validate(self):
19411 
    return
19412 
 
19413 
 
2591 chandransh 19414 
  def __repr__(self):
19415 
    L = ['%s=%r' % (key, value)
19416 
      for key, value in self.__dict__.iteritems()]
19417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19418 
 
19419 
  def __eq__(self, other):
19420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19421 
 
19422 
  def __ne__(self, other):
19423 
    return not (self == other)
19424 
 
19425 
class validateDoa_result:
19426 
  """
19427 
  Attributes:
19428 
   - success
19429 
   - ex
19430 
  """
19431 
 
19432 
  thrift_spec = (
19433 
    (0, TType.BOOL, 'success', None, None, ), # 0
19434 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19435 
  )
19436 
 
19437 
  def __init__(self, success=None, ex=None,):
19438 
    self.success = success
19439 
    self.ex = ex
19440 
 
19441 
  def read(self, iprot):
19442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19444 
      return
19445 
    iprot.readStructBegin()
19446 
    while True:
19447 
      (fname, ftype, fid) = iprot.readFieldBegin()
19448 
      if ftype == TType.STOP:
19449 
        break
19450 
      if fid == 0:
19451 
        if ftype == TType.BOOL:
19452 
          self.success = iprot.readBool();
19453 
        else:
19454 
          iprot.skip(ftype)
19455 
      elif fid == 1:
19456 
        if ftype == TType.STRUCT:
19457 
          self.ex = TransactionServiceException()
19458 
          self.ex.read(iprot)
19459 
        else:
19460 
          iprot.skip(ftype)
19461 
      else:
19462 
        iprot.skip(ftype)
19463 
      iprot.readFieldEnd()
19464 
    iprot.readStructEnd()
19465 
 
19466 
  def write(self, oprot):
19467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19469 
      return
19470 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 19471 
    if self.success is not None:
2591 chandransh 19472 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19473 
      oprot.writeBool(self.success)
19474 
      oprot.writeFieldEnd()
3431 rajveer 19475 
    if self.ex is not None:
2591 chandransh 19476 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19477 
      self.ex.write(oprot)
19478 
      oprot.writeFieldEnd()
19479 
    oprot.writeFieldStop()
19480 
    oprot.writeStructEnd()
19481 
 
3431 rajveer 19482 
  def validate(self):
19483 
    return
19484 
 
19485 
 
2591 chandransh 19486 
  def __repr__(self):
19487 
    L = ['%s=%r' % (key, value)
19488 
      for key, value in self.__dict__.iteritems()]
19489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19490 
 
19491 
  def __eq__(self, other):
19492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19493 
 
19494 
  def __ne__(self, other):
19495 
    return not (self == other)
19496 
 
4495 rajveer 19497 
class validateReturnProduct_args:
19498 
  """
19499 
  Attributes:
19500 
   - orderId
19501 
   - isUsable
19502 
  """
19503 
 
19504 
  thrift_spec = (
19505 
    None, # 0
19506 
    (1, TType.I64, 'orderId', None, None, ), # 1
19507 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
19508 
  )
19509 
 
19510 
  def __init__(self, orderId=None, isUsable=None,):
19511 
    self.orderId = orderId
19512 
    self.isUsable = isUsable
19513 
 
19514 
  def read(self, iprot):
19515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19517 
      return
19518 
    iprot.readStructBegin()
19519 
    while True:
19520 
      (fname, ftype, fid) = iprot.readFieldBegin()
19521 
      if ftype == TType.STOP:
19522 
        break
19523 
      if fid == 1:
19524 
        if ftype == TType.I64:
19525 
          self.orderId = iprot.readI64();
19526 
        else:
19527 
          iprot.skip(ftype)
19528 
      elif fid == 2:
19529 
        if ftype == TType.BOOL:
19530 
          self.isUsable = iprot.readBool();
19531 
        else:
19532 
          iprot.skip(ftype)
19533 
      else:
19534 
        iprot.skip(ftype)
19535 
      iprot.readFieldEnd()
19536 
    iprot.readStructEnd()
19537 
 
19538 
  def write(self, oprot):
19539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19541 
      return
19542 
    oprot.writeStructBegin('validateReturnProduct_args')
19543 
    if self.orderId is not None:
19544 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19545 
      oprot.writeI64(self.orderId)
19546 
      oprot.writeFieldEnd()
19547 
    if self.isUsable is not None:
19548 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
19549 
      oprot.writeBool(self.isUsable)
19550 
      oprot.writeFieldEnd()
19551 
    oprot.writeFieldStop()
19552 
    oprot.writeStructEnd()
19553 
 
19554 
  def validate(self):
19555 
    return
19556 
 
19557 
 
19558 
  def __repr__(self):
19559 
    L = ['%s=%r' % (key, value)
19560 
      for key, value in self.__dict__.iteritems()]
19561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19562 
 
19563 
  def __eq__(self, other):
19564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19565 
 
19566 
  def __ne__(self, other):
19567 
    return not (self == other)
19568 
 
19569 
class validateReturnProduct_result:
19570 
  """
19571 
  Attributes:
19572 
   - success
19573 
   - ex
19574 
  """
19575 
 
19576 
  thrift_spec = (
19577 
    (0, TType.BOOL, 'success', None, None, ), # 0
19578 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19579 
  )
19580 
 
19581 
  def __init__(self, success=None, ex=None,):
19582 
    self.success = success
19583 
    self.ex = ex
19584 
 
19585 
  def read(self, iprot):
19586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19588 
      return
19589 
    iprot.readStructBegin()
19590 
    while True:
19591 
      (fname, ftype, fid) = iprot.readFieldBegin()
19592 
      if ftype == TType.STOP:
19593 
        break
19594 
      if fid == 0:
19595 
        if ftype == TType.BOOL:
19596 
          self.success = iprot.readBool();
19597 
        else:
19598 
          iprot.skip(ftype)
19599 
      elif fid == 1:
19600 
        if ftype == TType.STRUCT:
19601 
          self.ex = TransactionServiceException()
19602 
          self.ex.read(iprot)
19603 
        else:
19604 
          iprot.skip(ftype)
19605 
      else:
19606 
        iprot.skip(ftype)
19607 
      iprot.readFieldEnd()
19608 
    iprot.readStructEnd()
19609 
 
19610 
  def write(self, oprot):
19611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19613 
      return
19614 
    oprot.writeStructBegin('validateReturnProduct_result')
19615 
    if self.success is not None:
19616 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19617 
      oprot.writeBool(self.success)
19618 
      oprot.writeFieldEnd()
19619 
    if self.ex is not None:
19620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19621 
      self.ex.write(oprot)
19622 
      oprot.writeFieldEnd()
19623 
    oprot.writeFieldStop()
19624 
    oprot.writeStructEnd()
19625 
 
19626 
  def validate(self):
19627 
    return
19628 
 
19629 
 
19630 
  def __repr__(self):
19631 
    L = ['%s=%r' % (key, value)
19632 
      for key, value in self.__dict__.iteritems()]
19633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19634 
 
19635 
  def __eq__(self, other):
19636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19637 
 
19638 
  def __ne__(self, other):
19639 
    return not (self == other)
19640 
 
2616 chandransh 19641 
class reshipOrder_args:
19642 
  """
19643 
  Attributes:
19644 
   - orderId
19645 
  """
2591 chandransh 19646 
 
2616 chandransh 19647 
  thrift_spec = (
19648 
    None, # 0
19649 
    (1, TType.I64, 'orderId', None, None, ), # 1
19650 
  )
19651 
 
19652 
  def __init__(self, orderId=None,):
19653 
    self.orderId = orderId
19654 
 
19655 
  def read(self, iprot):
19656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19658 
      return
19659 
    iprot.readStructBegin()
19660 
    while True:
19661 
      (fname, ftype, fid) = iprot.readFieldBegin()
19662 
      if ftype == TType.STOP:
19663 
        break
19664 
      if fid == 1:
19665 
        if ftype == TType.I64:
19666 
          self.orderId = iprot.readI64();
19667 
        else:
19668 
          iprot.skip(ftype)
19669 
      else:
19670 
        iprot.skip(ftype)
19671 
      iprot.readFieldEnd()
19672 
    iprot.readStructEnd()
19673 
 
19674 
  def write(self, oprot):
19675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19677 
      return
19678 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19679 
    if self.orderId is not None:
2616 chandransh 19680 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19681 
      oprot.writeI64(self.orderId)
19682 
      oprot.writeFieldEnd()
19683 
    oprot.writeFieldStop()
19684 
    oprot.writeStructEnd()
19685 
 
3431 rajveer 19686 
  def validate(self):
19687 
    return
19688 
 
19689 
 
2616 chandransh 19690 
  def __repr__(self):
19691 
    L = ['%s=%r' % (key, value)
19692 
      for key, value in self.__dict__.iteritems()]
19693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19694 
 
19695 
  def __eq__(self, other):
19696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19697 
 
19698 
  def __ne__(self, other):
19699 
    return not (self == other)
19700 
 
19701 
class reshipOrder_result:
19702 
  """
19703 
  Attributes:
19704 
   - success
19705 
   - ex
19706 
  """
19707 
 
19708 
  thrift_spec = (
19709 
    (0, TType.I64, 'success', None, None, ), # 0
19710 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19711 
  )
19712 
 
19713 
  def __init__(self, success=None, ex=None,):
19714 
    self.success = success
19715 
    self.ex = ex
19716 
 
19717 
  def read(self, iprot):
19718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19720 
      return
19721 
    iprot.readStructBegin()
19722 
    while True:
19723 
      (fname, ftype, fid) = iprot.readFieldBegin()
19724 
      if ftype == TType.STOP:
19725 
        break
19726 
      if fid == 0:
19727 
        if ftype == TType.I64:
19728 
          self.success = iprot.readI64();
19729 
        else:
19730 
          iprot.skip(ftype)
19731 
      elif fid == 1:
19732 
        if ftype == TType.STRUCT:
19733 
          self.ex = TransactionServiceException()
19734 
          self.ex.read(iprot)
19735 
        else:
19736 
          iprot.skip(ftype)
19737 
      else:
19738 
        iprot.skip(ftype)
19739 
      iprot.readFieldEnd()
19740 
    iprot.readStructEnd()
19741 
 
19742 
  def write(self, oprot):
19743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19745 
      return
19746 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19747 
    if self.success is not None:
2616 chandransh 19748 
      oprot.writeFieldBegin('success', TType.I64, 0)
19749 
      oprot.writeI64(self.success)
19750 
      oprot.writeFieldEnd()
3431 rajveer 19751 
    if self.ex is not None:
2616 chandransh 19752 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19753 
      self.ex.write(oprot)
19754 
      oprot.writeFieldEnd()
19755 
    oprot.writeFieldStop()
19756 
    oprot.writeStructEnd()
19757 
 
3431 rajveer 19758 
  def validate(self):
19759 
    return
19760 
 
19761 
 
2616 chandransh 19762 
  def __repr__(self):
19763 
    L = ['%s=%r' % (key, value)
19764 
      for key, value in self.__dict__.iteritems()]
19765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19766 
 
19767 
  def __eq__(self, other):
19768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19769 
 
19770 
  def __ne__(self, other):
19771 
    return not (self == other)
19772 
 
19773 
class refundOrder_args:
19774 
  """
19775 
  Attributes:
19776 
   - orderId
3226 chandransh 19777 
   - refundedBy
19778 
   - reason
2616 chandransh 19779 
  """
19780 
 
19781 
  thrift_spec = (
19782 
    None, # 0
19783 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19784 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19785 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19786 
  )
19787 
 
3226 chandransh 19788 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19789 
    self.orderId = orderId
3226 chandransh 19790 
    self.refundedBy = refundedBy
19791 
    self.reason = reason
2616 chandransh 19792 
 
19793 
  def read(self, iprot):
19794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19796 
      return
19797 
    iprot.readStructBegin()
19798 
    while True:
19799 
      (fname, ftype, fid) = iprot.readFieldBegin()
19800 
      if ftype == TType.STOP:
19801 
        break
19802 
      if fid == 1:
19803 
        if ftype == TType.I64:
19804 
          self.orderId = iprot.readI64();
19805 
        else:
19806 
          iprot.skip(ftype)
3226 chandransh 19807 
      elif fid == 2:
19808 
        if ftype == TType.STRING:
19809 
          self.refundedBy = iprot.readString();
19810 
        else:
19811 
          iprot.skip(ftype)
19812 
      elif fid == 3:
19813 
        if ftype == TType.STRING:
19814 
          self.reason = iprot.readString();
19815 
        else:
19816 
          iprot.skip(ftype)
2616 chandransh 19817 
      else:
19818 
        iprot.skip(ftype)
19819 
      iprot.readFieldEnd()
19820 
    iprot.readStructEnd()
19821 
 
19822 
  def write(self, oprot):
19823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19825 
      return
19826 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19827 
    if self.orderId is not None:
2616 chandransh 19828 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19829 
      oprot.writeI64(self.orderId)
19830 
      oprot.writeFieldEnd()
3431 rajveer 19831 
    if self.refundedBy is not None:
3226 chandransh 19832 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19833 
      oprot.writeString(self.refundedBy)
19834 
      oprot.writeFieldEnd()
3431 rajveer 19835 
    if self.reason is not None:
3226 chandransh 19836 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19837 
      oprot.writeString(self.reason)
19838 
      oprot.writeFieldEnd()
2616 chandransh 19839 
    oprot.writeFieldStop()
19840 
    oprot.writeStructEnd()
19841 
 
3431 rajveer 19842 
  def validate(self):
19843 
    return
19844 
 
19845 
 
2616 chandransh 19846 
  def __repr__(self):
19847 
    L = ['%s=%r' % (key, value)
19848 
      for key, value in self.__dict__.iteritems()]
19849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19850 
 
19851 
  def __eq__(self, other):
19852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19853 
 
19854 
  def __ne__(self, other):
19855 
    return not (self == other)
19856 
 
19857 
class refundOrder_result:
19858 
  """
19859 
  Attributes:
19860 
   - success
19861 
   - ex
19862 
  """
19863 
 
19864 
  thrift_spec = (
19865 
    (0, TType.BOOL, 'success', None, None, ), # 0
19866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19867 
  )
19868 
 
19869 
  def __init__(self, success=None, ex=None,):
19870 
    self.success = success
19871 
    self.ex = ex
19872 
 
19873 
  def read(self, iprot):
19874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19876 
      return
19877 
    iprot.readStructBegin()
19878 
    while True:
19879 
      (fname, ftype, fid) = iprot.readFieldBegin()
19880 
      if ftype == TType.STOP:
19881 
        break
19882 
      if fid == 0:
19883 
        if ftype == TType.BOOL:
19884 
          self.success = iprot.readBool();
19885 
        else:
19886 
          iprot.skip(ftype)
19887 
      elif fid == 1:
19888 
        if ftype == TType.STRUCT:
19889 
          self.ex = TransactionServiceException()
19890 
          self.ex.read(iprot)
19891 
        else:
19892 
          iprot.skip(ftype)
19893 
      else:
19894 
        iprot.skip(ftype)
19895 
      iprot.readFieldEnd()
19896 
    iprot.readStructEnd()
19897 
 
19898 
  def write(self, oprot):
19899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19901 
      return
19902 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19903 
    if self.success is not None:
2616 chandransh 19904 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19905 
      oprot.writeBool(self.success)
19906 
      oprot.writeFieldEnd()
3431 rajveer 19907 
    if self.ex is not None:
2616 chandransh 19908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19909 
      self.ex.write(oprot)
19910 
      oprot.writeFieldEnd()
19911 
    oprot.writeFieldStop()
19912 
    oprot.writeStructEnd()
19913 
 
3431 rajveer 19914 
  def validate(self):
19915 
    return
19916 
 
19917 
 
2616 chandransh 19918 
  def __repr__(self):
19919 
    L = ['%s=%r' % (key, value)
19920 
      for key, value in self.__dict__.iteritems()]
19921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19922 
 
19923 
  def __eq__(self, other):
19924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19925 
 
19926 
  def __ne__(self, other):
19927 
    return not (self == other)
19928 
 
2690 chandransh 19929 
class getReturnOrders_args:
19930 
  """
19931 
  Attributes:
19932 
   - warehouseId
19933 
   - fromDate
19934 
   - toDate
19935 
  """
2616 chandransh 19936 
 
2690 chandransh 19937 
  thrift_spec = (
19938 
    None, # 0
19939 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19940 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19941 
    (3, TType.I64, 'toDate', None, None, ), # 3
19942 
  )
19943 
 
19944 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19945 
    self.warehouseId = warehouseId
19946 
    self.fromDate = fromDate
19947 
    self.toDate = toDate
19948 
 
19949 
  def read(self, iprot):
19950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19952 
      return
19953 
    iprot.readStructBegin()
19954 
    while True:
19955 
      (fname, ftype, fid) = iprot.readFieldBegin()
19956 
      if ftype == TType.STOP:
19957 
        break
19958 
      if fid == 1:
19959 
        if ftype == TType.I64:
19960 
          self.warehouseId = iprot.readI64();
19961 
        else:
19962 
          iprot.skip(ftype)
19963 
      elif fid == 2:
19964 
        if ftype == TType.I64:
19965 
          self.fromDate = iprot.readI64();
19966 
        else:
19967 
          iprot.skip(ftype)
19968 
      elif fid == 3:
19969 
        if ftype == TType.I64:
19970 
          self.toDate = iprot.readI64();
19971 
        else:
19972 
          iprot.skip(ftype)
19973 
      else:
19974 
        iprot.skip(ftype)
19975 
      iprot.readFieldEnd()
19976 
    iprot.readStructEnd()
19977 
 
19978 
  def write(self, oprot):
19979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19981 
      return
19982 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19983 
    if self.warehouseId is not None:
2690 chandransh 19984 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19985 
      oprot.writeI64(self.warehouseId)
19986 
      oprot.writeFieldEnd()
3431 rajveer 19987 
    if self.fromDate is not None:
2690 chandransh 19988 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19989 
      oprot.writeI64(self.fromDate)
19990 
      oprot.writeFieldEnd()
3431 rajveer 19991 
    if self.toDate is not None:
2690 chandransh 19992 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19993 
      oprot.writeI64(self.toDate)
19994 
      oprot.writeFieldEnd()
19995 
    oprot.writeFieldStop()
19996 
    oprot.writeStructEnd()
19997 
 
3431 rajveer 19998 
  def validate(self):
19999 
    return
20000 
 
20001 
 
2690 chandransh 20002 
  def __repr__(self):
20003 
    L = ['%s=%r' % (key, value)
20004 
      for key, value in self.__dict__.iteritems()]
20005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20006 
 
20007 
  def __eq__(self, other):
20008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20009 
 
20010 
  def __ne__(self, other):
20011 
    return not (self == other)
20012 
 
20013 
class getReturnOrders_result:
20014 
  """
20015 
  Attributes:
20016 
   - success
20017 
  """
20018 
 
20019 
  thrift_spec = (
20020 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
20021 
  )
20022 
 
20023 
  def __init__(self, success=None,):
20024 
    self.success = success
20025 
 
20026 
  def read(self, iprot):
20027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20029 
      return
20030 
    iprot.readStructBegin()
20031 
    while True:
20032 
      (fname, ftype, fid) = iprot.readFieldBegin()
20033 
      if ftype == TType.STOP:
20034 
        break
20035 
      if fid == 0:
20036 
        if ftype == TType.LIST:
20037 
          self.success = []
6188 rajveer 20038 
          (_etype442, _size439) = iprot.readListBegin()
20039 
          for _i443 in xrange(_size439):
20040 
            _elem444 = ReturnOrder()
20041 
            _elem444.read(iprot)
20042 
            self.success.append(_elem444)
2690 chandransh 20043 
          iprot.readListEnd()
20044 
        else:
20045 
          iprot.skip(ftype)
20046 
      else:
20047 
        iprot.skip(ftype)
20048 
      iprot.readFieldEnd()
20049 
    iprot.readStructEnd()
20050 
 
20051 
  def write(self, oprot):
20052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20054 
      return
20055 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 20056 
    if self.success is not None:
2690 chandransh 20057 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20058 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20059 
      for iter445 in self.success:
20060 
        iter445.write(oprot)
2690 chandransh 20061 
      oprot.writeListEnd()
20062 
      oprot.writeFieldEnd()
20063 
    oprot.writeFieldStop()
20064 
    oprot.writeStructEnd()
20065 
 
3431 rajveer 20066 
  def validate(self):
20067 
    return
20068 
 
20069 
 
2690 chandransh 20070 
  def __repr__(self):
20071 
    L = ['%s=%r' % (key, value)
20072 
      for key, value in self.__dict__.iteritems()]
20073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20074 
 
20075 
  def __eq__(self, other):
20076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20077 
 
20078 
  def __ne__(self, other):
20079 
    return not (self == other)
20080 
 
5481 phani.kuma 20081 
class getAllReturnOrders_args:
20082 
  """
20083 
  Attributes:
20084 
   - onlyNotProcessed
20085 
   - fromDate
20086 
   - toDate
20087 
  """
20088 
 
20089 
  thrift_spec = (
20090 
    None, # 0
20091 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
20092 
    (2, TType.I64, 'fromDate', None, None, ), # 2
20093 
    (3, TType.I64, 'toDate', None, None, ), # 3
20094 
  )
20095 
 
20096 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
20097 
    self.onlyNotProcessed = onlyNotProcessed
20098 
    self.fromDate = fromDate
20099 
    self.toDate = toDate
20100 
 
20101 
  def read(self, iprot):
20102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20104 
      return
20105 
    iprot.readStructBegin()
20106 
    while True:
20107 
      (fname, ftype, fid) = iprot.readFieldBegin()
20108 
      if ftype == TType.STOP:
20109 
        break
20110 
      if fid == 1:
20111 
        if ftype == TType.BOOL:
20112 
          self.onlyNotProcessed = iprot.readBool();
20113 
        else:
20114 
          iprot.skip(ftype)
20115 
      elif fid == 2:
20116 
        if ftype == TType.I64:
20117 
          self.fromDate = iprot.readI64();
20118 
        else:
20119 
          iprot.skip(ftype)
20120 
      elif fid == 3:
20121 
        if ftype == TType.I64:
20122 
          self.toDate = iprot.readI64();
20123 
        else:
20124 
          iprot.skip(ftype)
20125 
      else:
20126 
        iprot.skip(ftype)
20127 
      iprot.readFieldEnd()
20128 
    iprot.readStructEnd()
20129 
 
20130 
  def write(self, oprot):
20131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20133 
      return
20134 
    oprot.writeStructBegin('getAllReturnOrders_args')
20135 
    if self.onlyNotProcessed is not None:
20136 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
20137 
      oprot.writeBool(self.onlyNotProcessed)
20138 
      oprot.writeFieldEnd()
20139 
    if self.fromDate is not None:
20140 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
20141 
      oprot.writeI64(self.fromDate)
20142 
      oprot.writeFieldEnd()
20143 
    if self.toDate is not None:
20144 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
20145 
      oprot.writeI64(self.toDate)
20146 
      oprot.writeFieldEnd()
20147 
    oprot.writeFieldStop()
20148 
    oprot.writeStructEnd()
20149 
 
20150 
  def validate(self):
20151 
    return
20152 
 
20153 
 
20154 
  def __repr__(self):
20155 
    L = ['%s=%r' % (key, value)
20156 
      for key, value in self.__dict__.iteritems()]
20157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20158 
 
20159 
  def __eq__(self, other):
20160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20161 
 
20162 
  def __ne__(self, other):
20163 
    return not (self == other)
20164 
 
20165 
class getAllReturnOrders_result:
20166 
  """
20167 
  Attributes:
20168 
   - success
20169 
  """
20170 
 
20171 
  thrift_spec = (
20172 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
20173 
  )
20174 
 
20175 
  def __init__(self, success=None,):
20176 
    self.success = success
20177 
 
20178 
  def read(self, iprot):
20179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20181 
      return
20182 
    iprot.readStructBegin()
20183 
    while True:
20184 
      (fname, ftype, fid) = iprot.readFieldBegin()
20185 
      if ftype == TType.STOP:
20186 
        break
20187 
      if fid == 0:
20188 
        if ftype == TType.LIST:
20189 
          self.success = []
6188 rajveer 20190 
          (_etype449, _size446) = iprot.readListBegin()
20191 
          for _i450 in xrange(_size446):
20192 
            _elem451 = ReturnOrder()
20193 
            _elem451.read(iprot)
20194 
            self.success.append(_elem451)
5481 phani.kuma 20195 
          iprot.readListEnd()
20196 
        else:
20197 
          iprot.skip(ftype)
20198 
      else:
20199 
        iprot.skip(ftype)
20200 
      iprot.readFieldEnd()
20201 
    iprot.readStructEnd()
20202 
 
20203 
  def write(self, oprot):
20204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20206 
      return
20207 
    oprot.writeStructBegin('getAllReturnOrders_result')
20208 
    if self.success is not None:
20209 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20210 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20211 
      for iter452 in self.success:
20212 
        iter452.write(oprot)
5481 phani.kuma 20213 
      oprot.writeListEnd()
20214 
      oprot.writeFieldEnd()
20215 
    oprot.writeFieldStop()
20216 
    oprot.writeStructEnd()
20217 
 
20218 
  def validate(self):
20219 
    return
20220 
 
20221 
 
20222 
  def __repr__(self):
20223 
    L = ['%s=%r' % (key, value)
20224 
      for key, value in self.__dict__.iteritems()]
20225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20226 
 
20227 
  def __eq__(self, other):
20228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20229 
 
20230 
  def __ne__(self, other):
20231 
    return not (self == other)
20232 
 
2700 chandransh 20233 
class getReturnOrder_args:
20234 
  """
20235 
  Attributes:
20236 
   - id
20237 
  """
20238 
 
20239 
  thrift_spec = (
20240 
    None, # 0
20241 
    (1, TType.I64, 'id', None, None, ), # 1
20242 
  )
20243 
 
20244 
  def __init__(self, id=None,):
20245 
    self.id = id
20246 
 
20247 
  def read(self, iprot):
20248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20250 
      return
20251 
    iprot.readStructBegin()
20252 
    while True:
20253 
      (fname, ftype, fid) = iprot.readFieldBegin()
20254 
      if ftype == TType.STOP:
20255 
        break
20256 
      if fid == 1:
20257 
        if ftype == TType.I64:
20258 
          self.id = iprot.readI64();
20259 
        else:
20260 
          iprot.skip(ftype)
20261 
      else:
20262 
        iprot.skip(ftype)
20263 
      iprot.readFieldEnd()
20264 
    iprot.readStructEnd()
20265 
 
20266 
  def write(self, oprot):
20267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20269 
      return
20270 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 20271 
    if self.id is not None:
2700 chandransh 20272 
      oprot.writeFieldBegin('id', TType.I64, 1)
20273 
      oprot.writeI64(self.id)
20274 
      oprot.writeFieldEnd()
20275 
    oprot.writeFieldStop()
20276 
    oprot.writeStructEnd()
20277 
 
3431 rajveer 20278 
  def validate(self):
20279 
    return
20280 
 
20281 
 
2700 chandransh 20282 
  def __repr__(self):
20283 
    L = ['%s=%r' % (key, value)
20284 
      for key, value in self.__dict__.iteritems()]
20285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20286 
 
20287 
  def __eq__(self, other):
20288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20289 
 
20290 
  def __ne__(self, other):
20291 
    return not (self == other)
20292 
 
20293 
class getReturnOrder_result:
20294 
  """
20295 
  Attributes:
20296 
   - success
20297 
   - ex
20298 
  """
20299 
 
20300 
  thrift_spec = (
20301 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
20302 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20303 
  )
20304 
 
20305 
  def __init__(self, success=None, ex=None,):
20306 
    self.success = success
20307 
    self.ex = ex
20308 
 
20309 
  def read(self, iprot):
20310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20312 
      return
20313 
    iprot.readStructBegin()
20314 
    while True:
20315 
      (fname, ftype, fid) = iprot.readFieldBegin()
20316 
      if ftype == TType.STOP:
20317 
        break
20318 
      if fid == 0:
20319 
        if ftype == TType.STRUCT:
20320 
          self.success = ReturnOrder()
20321 
          self.success.read(iprot)
20322 
        else:
20323 
          iprot.skip(ftype)
20324 
      elif fid == 1:
20325 
        if ftype == TType.STRUCT:
20326 
          self.ex = TransactionServiceException()
20327 
          self.ex.read(iprot)
20328 
        else:
20329 
          iprot.skip(ftype)
20330 
      else:
20331 
        iprot.skip(ftype)
20332 
      iprot.readFieldEnd()
20333 
    iprot.readStructEnd()
20334 
 
20335 
  def write(self, oprot):
20336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20338 
      return
20339 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 20340 
    if self.success is not None:
2700 chandransh 20341 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20342 
      self.success.write(oprot)
20343 
      oprot.writeFieldEnd()
3431 rajveer 20344 
    if self.ex is not None:
2700 chandransh 20345 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20346 
      self.ex.write(oprot)
20347 
      oprot.writeFieldEnd()
20348 
    oprot.writeFieldStop()
20349 
    oprot.writeStructEnd()
20350 
 
3431 rajveer 20351 
  def validate(self):
20352 
    return
20353 
 
20354 
 
2700 chandransh 20355 
  def __repr__(self):
20356 
    L = ['%s=%r' % (key, value)
20357 
      for key, value in self.__dict__.iteritems()]
20358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20359 
 
20360 
  def __eq__(self, other):
20361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20362 
 
20363 
  def __ne__(self, other):
20364 
    return not (self == other)
20365 
 
2690 chandransh 20366 
class processReturn_args:
20367 
  """
20368 
  Attributes:
20369 
   - returnOrderId
20370 
  """
20371 
 
20372 
  thrift_spec = (
20373 
    None, # 0
20374 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
20375 
  )
20376 
 
20377 
  def __init__(self, returnOrderId=None,):
20378 
    self.returnOrderId = returnOrderId
20379 
 
20380 
  def read(self, iprot):
20381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20383 
      return
20384 
    iprot.readStructBegin()
20385 
    while True:
20386 
      (fname, ftype, fid) = iprot.readFieldBegin()
20387 
      if ftype == TType.STOP:
20388 
        break
20389 
      if fid == 1:
20390 
        if ftype == TType.I64:
20391 
          self.returnOrderId = iprot.readI64();
20392 
        else:
20393 
          iprot.skip(ftype)
20394 
      else:
20395 
        iprot.skip(ftype)
20396 
      iprot.readFieldEnd()
20397 
    iprot.readStructEnd()
20398 
 
20399 
  def write(self, oprot):
20400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20402 
      return
20403 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 20404 
    if self.returnOrderId is not None:
2690 chandransh 20405 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
20406 
      oprot.writeI64(self.returnOrderId)
20407 
      oprot.writeFieldEnd()
20408 
    oprot.writeFieldStop()
20409 
    oprot.writeStructEnd()
20410 
 
3431 rajveer 20411 
  def validate(self):
20412 
    return
20413 
 
20414 
 
2690 chandransh 20415 
  def __repr__(self):
20416 
    L = ['%s=%r' % (key, value)
20417 
      for key, value in self.__dict__.iteritems()]
20418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20419 
 
20420 
  def __eq__(self, other):
20421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20422 
 
20423 
  def __ne__(self, other):
20424 
    return not (self == other)
20425 
 
20426 
class processReturn_result:
20427 
  """
20428 
  Attributes:
20429 
   - ex
20430 
  """
20431 
 
20432 
  thrift_spec = (
20433 
    None, # 0
20434 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20435 
  )
20436 
 
20437 
  def __init__(self, ex=None,):
20438 
    self.ex = ex
20439 
 
20440 
  def read(self, iprot):
20441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20443 
      return
20444 
    iprot.readStructBegin()
20445 
    while True:
20446 
      (fname, ftype, fid) = iprot.readFieldBegin()
20447 
      if ftype == TType.STOP:
20448 
        break
20449 
      if fid == 1:
20450 
        if ftype == TType.STRUCT:
20451 
          self.ex = TransactionServiceException()
20452 
          self.ex.read(iprot)
20453 
        else:
20454 
          iprot.skip(ftype)
20455 
      else:
20456 
        iprot.skip(ftype)
20457 
      iprot.readFieldEnd()
20458 
    iprot.readStructEnd()
20459 
 
20460 
  def write(self, oprot):
20461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20463 
      return
20464 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 20465 
    if self.ex is not None:
2690 chandransh 20466 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20467 
      self.ex.write(oprot)
20468 
      oprot.writeFieldEnd()
20469 
    oprot.writeFieldStop()
20470 
    oprot.writeStructEnd()
20471 
 
3431 rajveer 20472 
  def validate(self):
20473 
    return
20474 
 
20475 
 
2690 chandransh 20476 
  def __repr__(self):
20477 
    L = ['%s=%r' % (key, value)
20478 
      for key, value in self.__dict__.iteritems()]
20479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20480 
 
20481 
  def __eq__(self, other):
20482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20483 
 
20484 
  def __ne__(self, other):
20485 
    return not (self == other)
20486 
 
3451 chandransh 20487 
class updateWeight_args:
20488 
  """
20489 
  Attributes:
20490 
   - orderId
20491 
   - weight
20492 
  """
20493 
 
20494 
  thrift_spec = (
20495 
    None, # 0
20496 
    (1, TType.I64, 'orderId', None, None, ), # 1
20497 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
20498 
  )
20499 
 
20500 
  def __init__(self, orderId=None, weight=None,):
20501 
    self.orderId = orderId
20502 
    self.weight = weight
20503 
 
20504 
  def read(self, iprot):
20505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20507 
      return
20508 
    iprot.readStructBegin()
20509 
    while True:
20510 
      (fname, ftype, fid) = iprot.readFieldBegin()
20511 
      if ftype == TType.STOP:
20512 
        break
20513 
      if fid == 1:
20514 
        if ftype == TType.I64:
20515 
          self.orderId = iprot.readI64();
20516 
        else:
20517 
          iprot.skip(ftype)
20518 
      elif fid == 2:
20519 
        if ftype == TType.DOUBLE:
20520 
          self.weight = iprot.readDouble();
20521 
        else:
20522 
          iprot.skip(ftype)
20523 
      else:
20524 
        iprot.skip(ftype)
20525 
      iprot.readFieldEnd()
20526 
    iprot.readStructEnd()
20527 
 
20528 
  def write(self, oprot):
20529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20531 
      return
20532 
    oprot.writeStructBegin('updateWeight_args')
20533 
    if self.orderId is not None:
20534 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20535 
      oprot.writeI64(self.orderId)
20536 
      oprot.writeFieldEnd()
20537 
    if self.weight is not None:
20538 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
20539 
      oprot.writeDouble(self.weight)
20540 
      oprot.writeFieldEnd()
20541 
    oprot.writeFieldStop()
20542 
    oprot.writeStructEnd()
20543 
 
20544 
  def validate(self):
20545 
    return
20546 
 
20547 
 
20548 
  def __repr__(self):
20549 
    L = ['%s=%r' % (key, value)
20550 
      for key, value in self.__dict__.iteritems()]
20551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20552 
 
20553 
  def __eq__(self, other):
20554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20555 
 
20556 
  def __ne__(self, other):
20557 
    return not (self == other)
20558 
 
20559 
class updateWeight_result:
20560 
  """
20561 
  Attributes:
20562 
   - success
20563 
   - ex
20564 
  """
20565 
 
20566 
  thrift_spec = (
20567 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20568 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20569 
  )
20570 
 
20571 
  def __init__(self, success=None, ex=None,):
20572 
    self.success = success
20573 
    self.ex = ex
20574 
 
20575 
  def read(self, iprot):
20576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20578 
      return
20579 
    iprot.readStructBegin()
20580 
    while True:
20581 
      (fname, ftype, fid) = iprot.readFieldBegin()
20582 
      if ftype == TType.STOP:
20583 
        break
20584 
      if fid == 0:
20585 
        if ftype == TType.STRUCT:
20586 
          self.success = Order()
20587 
          self.success.read(iprot)
20588 
        else:
20589 
          iprot.skip(ftype)
20590 
      elif fid == 1:
20591 
        if ftype == TType.STRUCT:
20592 
          self.ex = TransactionServiceException()
20593 
          self.ex.read(iprot)
20594 
        else:
20595 
          iprot.skip(ftype)
20596 
      else:
20597 
        iprot.skip(ftype)
20598 
      iprot.readFieldEnd()
20599 
    iprot.readStructEnd()
20600 
 
20601 
  def write(self, oprot):
20602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20604 
      return
20605 
    oprot.writeStructBegin('updateWeight_result')
20606 
    if self.success is not None:
20607 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20608 
      self.success.write(oprot)
20609 
      oprot.writeFieldEnd()
20610 
    if self.ex is not None:
20611 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20612 
      self.ex.write(oprot)
20613 
      oprot.writeFieldEnd()
20614 
    oprot.writeFieldStop()
20615 
    oprot.writeStructEnd()
20616 
 
20617 
  def validate(self):
20618 
    return
20619 
 
20620 
 
20621 
  def __repr__(self):
20622 
    L = ['%s=%r' % (key, value)
20623 
      for key, value in self.__dict__.iteritems()]
20624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20625 
 
20626 
  def __eq__(self, other):
20627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20628 
 
20629 
  def __ne__(self, other):
20630 
    return not (self == other)
3469 chandransh 20631 
 
20632 
class changeItem_args:
20633 
  """
20634 
  Attributes:
20635 
   - orderId
20636 
   - itemId
20637 
  """
20638 
 
20639 
  thrift_spec = (
20640 
    None, # 0
20641 
    (1, TType.I64, 'orderId', None, None, ), # 1
20642 
    (2, TType.I64, 'itemId', None, None, ), # 2
20643 
  )
20644 
 
20645 
  def __init__(self, orderId=None, itemId=None,):
20646 
    self.orderId = orderId
20647 
    self.itemId = itemId
20648 
 
20649 
  def read(self, iprot):
20650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20652 
      return
20653 
    iprot.readStructBegin()
20654 
    while True:
20655 
      (fname, ftype, fid) = iprot.readFieldBegin()
20656 
      if ftype == TType.STOP:
20657 
        break
20658 
      if fid == 1:
20659 
        if ftype == TType.I64:
20660 
          self.orderId = iprot.readI64();
20661 
        else:
20662 
          iprot.skip(ftype)
20663 
      elif fid == 2:
20664 
        if ftype == TType.I64:
20665 
          self.itemId = iprot.readI64();
20666 
        else:
20667 
          iprot.skip(ftype)
20668 
      else:
20669 
        iprot.skip(ftype)
20670 
      iprot.readFieldEnd()
20671 
    iprot.readStructEnd()
20672 
 
20673 
  def write(self, oprot):
20674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20676 
      return
20677 
    oprot.writeStructBegin('changeItem_args')
20678 
    if self.orderId is not None:
20679 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20680 
      oprot.writeI64(self.orderId)
20681 
      oprot.writeFieldEnd()
20682 
    if self.itemId is not None:
20683 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20684 
      oprot.writeI64(self.itemId)
20685 
      oprot.writeFieldEnd()
20686 
    oprot.writeFieldStop()
20687 
    oprot.writeStructEnd()
20688 
 
20689 
  def validate(self):
20690 
    return
20691 
 
20692 
 
20693 
  def __repr__(self):
20694 
    L = ['%s=%r' % (key, value)
20695 
      for key, value in self.__dict__.iteritems()]
20696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20697 
 
20698 
  def __eq__(self, other):
20699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20700 
 
20701 
  def __ne__(self, other):
20702 
    return not (self == other)
20703 
 
20704 
class changeItem_result:
20705 
  """
20706 
  Attributes:
20707 
   - success
20708 
   - ex
20709 
  """
20710 
 
20711 
  thrift_spec = (
20712 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20714 
  )
20715 
 
20716 
  def __init__(self, success=None, ex=None,):
20717 
    self.success = success
20718 
    self.ex = ex
20719 
 
20720 
  def read(self, iprot):
20721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20723 
      return
20724 
    iprot.readStructBegin()
20725 
    while True:
20726 
      (fname, ftype, fid) = iprot.readFieldBegin()
20727 
      if ftype == TType.STOP:
20728 
        break
20729 
      if fid == 0:
20730 
        if ftype == TType.STRUCT:
20731 
          self.success = Order()
20732 
          self.success.read(iprot)
20733 
        else:
20734 
          iprot.skip(ftype)
20735 
      elif fid == 1:
20736 
        if ftype == TType.STRUCT:
20737 
          self.ex = TransactionServiceException()
20738 
          self.ex.read(iprot)
20739 
        else:
20740 
          iprot.skip(ftype)
20741 
      else:
20742 
        iprot.skip(ftype)
20743 
      iprot.readFieldEnd()
20744 
    iprot.readStructEnd()
20745 
 
20746 
  def write(self, oprot):
20747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20749 
      return
20750 
    oprot.writeStructBegin('changeItem_result')
20751 
    if self.success is not None:
20752 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20753 
      self.success.write(oprot)
20754 
      oprot.writeFieldEnd()
20755 
    if self.ex is not None:
20756 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20757 
      self.ex.write(oprot)
20758 
      oprot.writeFieldEnd()
20759 
    oprot.writeFieldStop()
20760 
    oprot.writeStructEnd()
20761 
 
20762 
  def validate(self):
20763 
    return
20764 
 
20765 
 
20766 
  def __repr__(self):
20767 
    L = ['%s=%r' % (key, value)
20768 
      for key, value in self.__dict__.iteritems()]
20769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20770 
 
20771 
  def __eq__(self, other):
20772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20773 
 
20774 
  def __ne__(self, other):
20775 
    return not (self == other)
20776 
 
20777 
class shiftToWarehouse_args:
20778 
  """
20779 
  Attributes:
20780 
   - orderId
20781 
   - warehouseId
20782 
  """
20783 
 
20784 
  thrift_spec = (
20785 
    None, # 0
20786 
    (1, TType.I64, 'orderId', None, None, ), # 1
20787 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20788 
  )
20789 
 
20790 
  def __init__(self, orderId=None, warehouseId=None,):
20791 
    self.orderId = orderId
20792 
    self.warehouseId = warehouseId
20793 
 
20794 
  def read(self, iprot):
20795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20797 
      return
20798 
    iprot.readStructBegin()
20799 
    while True:
20800 
      (fname, ftype, fid) = iprot.readFieldBegin()
20801 
      if ftype == TType.STOP:
20802 
        break
20803 
      if fid == 1:
20804 
        if ftype == TType.I64:
20805 
          self.orderId = iprot.readI64();
20806 
        else:
20807 
          iprot.skip(ftype)
20808 
      elif fid == 2:
20809 
        if ftype == TType.I64:
20810 
          self.warehouseId = iprot.readI64();
20811 
        else:
20812 
          iprot.skip(ftype)
20813 
      else:
20814 
        iprot.skip(ftype)
20815 
      iprot.readFieldEnd()
20816 
    iprot.readStructEnd()
20817 
 
20818 
  def write(self, oprot):
20819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20821 
      return
20822 
    oprot.writeStructBegin('shiftToWarehouse_args')
20823 
    if self.orderId is not None:
20824 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20825 
      oprot.writeI64(self.orderId)
20826 
      oprot.writeFieldEnd()
20827 
    if self.warehouseId is not None:
20828 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20829 
      oprot.writeI64(self.warehouseId)
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 shiftToWarehouse_result:
20850 
  """
20851 
  Attributes:
20852 
   - success
20853 
   - ex
20854 
  """
20855 
 
20856 
  thrift_spec = (
20857 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20859 
  )
20860 
 
20861 
  def __init__(self, success=None, ex=None,):
20862 
    self.success = success
20863 
    self.ex = ex
20864 
 
20865 
  def read(self, iprot):
20866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20868 
      return
20869 
    iprot.readStructBegin()
20870 
    while True:
20871 
      (fname, ftype, fid) = iprot.readFieldBegin()
20872 
      if ftype == TType.STOP:
20873 
        break
20874 
      if fid == 0:
20875 
        if ftype == TType.STRUCT:
20876 
          self.success = Order()
20877 
          self.success.read(iprot)
20878 
        else:
20879 
          iprot.skip(ftype)
20880 
      elif fid == 1:
20881 
        if ftype == TType.STRUCT:
20882 
          self.ex = TransactionServiceException()
20883 
          self.ex.read(iprot)
20884 
        else:
20885 
          iprot.skip(ftype)
20886 
      else:
20887 
        iprot.skip(ftype)
20888 
      iprot.readFieldEnd()
20889 
    iprot.readStructEnd()
20890 
 
20891 
  def write(self, oprot):
20892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20894 
      return
20895 
    oprot.writeStructBegin('shiftToWarehouse_result')
20896 
    if self.success is not None:
20897 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20898 
      self.success.write(oprot)
20899 
      oprot.writeFieldEnd()
20900 
    if self.ex is not None:
20901 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20902 
      self.ex.write(oprot)
20903 
      oprot.writeFieldEnd()
20904 
    oprot.writeFieldStop()
20905 
    oprot.writeStructEnd()
20906 
 
20907 
  def validate(self):
20908 
    return
20909 
 
20910 
 
20911 
  def __repr__(self):
20912 
    L = ['%s=%r' % (key, value)
20913 
      for key, value in self.__dict__.iteritems()]
20914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20915 
 
20916 
  def __eq__(self, other):
20917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20918 
 
20919 
  def __ne__(self, other):
20920 
    return not (self == other)
3553 chandransh 20921 
 
20922 
class addDelayReason_args:
20923 
  """
20924 
  Attributes:
20925 
   - orderId
20926 
   - delayReason
3986 chandransh 20927 
   - furtherDelay
4647 rajveer 20928 
   - delayReasonText
3553 chandransh 20929 
  """
20930 
 
20931 
  thrift_spec = (
20932 
    None, # 0
20933 
    (1, TType.I64, 'orderId', None, None, ), # 1
20934 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20935 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20936 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20937 
  )
20938 
 
4647 rajveer 20939 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20940 
    self.orderId = orderId
20941 
    self.delayReason = delayReason
3986 chandransh 20942 
    self.furtherDelay = furtherDelay
4647 rajveer 20943 
    self.delayReasonText = delayReasonText
3553 chandransh 20944 
 
20945 
  def read(self, iprot):
20946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20948 
      return
20949 
    iprot.readStructBegin()
20950 
    while True:
20951 
      (fname, ftype, fid) = iprot.readFieldBegin()
20952 
      if ftype == TType.STOP:
20953 
        break
20954 
      if fid == 1:
20955 
        if ftype == TType.I64:
20956 
          self.orderId = iprot.readI64();
20957 
        else:
20958 
          iprot.skip(ftype)
20959 
      elif fid == 2:
20960 
        if ftype == TType.I32:
20961 
          self.delayReason = iprot.readI32();
20962 
        else:
20963 
          iprot.skip(ftype)
3986 chandransh 20964 
      elif fid == 3:
20965 
        if ftype == TType.I64:
20966 
          self.furtherDelay = iprot.readI64();
20967 
        else:
20968 
          iprot.skip(ftype)
4647 rajveer 20969 
      elif fid == 4:
20970 
        if ftype == TType.STRING:
20971 
          self.delayReasonText = iprot.readString();
20972 
        else:
20973 
          iprot.skip(ftype)
3553 chandransh 20974 
      else:
20975 
        iprot.skip(ftype)
20976 
      iprot.readFieldEnd()
20977 
    iprot.readStructEnd()
20978 
 
20979 
  def write(self, oprot):
20980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20982 
      return
20983 
    oprot.writeStructBegin('addDelayReason_args')
20984 
    if self.orderId is not None:
20985 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20986 
      oprot.writeI64(self.orderId)
20987 
      oprot.writeFieldEnd()
20988 
    if self.delayReason is not None:
20989 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20990 
      oprot.writeI32(self.delayReason)
20991 
      oprot.writeFieldEnd()
3986 chandransh 20992 
    if self.furtherDelay is not None:
20993 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20994 
      oprot.writeI64(self.furtherDelay)
20995 
      oprot.writeFieldEnd()
4647 rajveer 20996 
    if self.delayReasonText is not None:
20997 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20998 
      oprot.writeString(self.delayReasonText)
20999 
      oprot.writeFieldEnd()
3553 chandransh 21000 
    oprot.writeFieldStop()
21001 
    oprot.writeStructEnd()
21002 
 
21003 
  def validate(self):
21004 
    return
21005 
 
21006 
 
21007 
  def __repr__(self):
21008 
    L = ['%s=%r' % (key, value)
21009 
      for key, value in self.__dict__.iteritems()]
21010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21011 
 
21012 
  def __eq__(self, other):
21013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21014 
 
21015 
  def __ne__(self, other):
21016 
    return not (self == other)
21017 
 
21018 
class addDelayReason_result:
21019 
  """
21020 
  Attributes:
21021 
   - success
21022 
   - ex
21023 
  """
21024 
 
21025 
  thrift_spec = (
21026 
    (0, TType.BOOL, 'success', None, None, ), # 0
21027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21028 
  )
21029 
 
21030 
  def __init__(self, success=None, ex=None,):
21031 
    self.success = success
21032 
    self.ex = ex
21033 
 
21034 
  def read(self, iprot):
21035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21037 
      return
21038 
    iprot.readStructBegin()
21039 
    while True:
21040 
      (fname, ftype, fid) = iprot.readFieldBegin()
21041 
      if ftype == TType.STOP:
21042 
        break
21043 
      if fid == 0:
21044 
        if ftype == TType.BOOL:
21045 
          self.success = iprot.readBool();
21046 
        else:
21047 
          iprot.skip(ftype)
21048 
      elif fid == 1:
21049 
        if ftype == TType.STRUCT:
21050 
          self.ex = TransactionServiceException()
21051 
          self.ex.read(iprot)
21052 
        else:
21053 
          iprot.skip(ftype)
21054 
      else:
21055 
        iprot.skip(ftype)
21056 
      iprot.readFieldEnd()
21057 
    iprot.readStructEnd()
21058 
 
21059 
  def write(self, oprot):
21060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21062 
      return
21063 
    oprot.writeStructBegin('addDelayReason_result')
21064 
    if self.success is not None:
21065 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21066 
      oprot.writeBool(self.success)
21067 
      oprot.writeFieldEnd()
21068 
    if self.ex is not None:
21069 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21070 
      self.ex.write(oprot)
21071 
      oprot.writeFieldEnd()
21072 
    oprot.writeFieldStop()
21073 
    oprot.writeStructEnd()
21074 
 
21075 
  def validate(self):
21076 
    return
21077 
 
21078 
 
21079 
  def __repr__(self):
21080 
    L = ['%s=%r' % (key, value)
21081 
      for key, value in self.__dict__.iteritems()]
21082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21083 
 
21084 
  def __eq__(self, other):
21085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21086 
 
21087 
  def __ne__(self, other):
21088 
    return not (self == other)
3956 chandransh 21089 
 
21090 
class reconcileCodCollection_args:
21091 
  """
21092 
  Attributes:
21093 
   - collectedAmountMap
21094 
   - xferBy
21095 
   - xferTxnId
21096 
   - xferDate
21097 
  """
21098 
 
21099 
  thrift_spec = (
21100 
    None, # 0
21101 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
21102 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
21103 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
21104 
    (4, TType.I64, 'xferDate', None, None, ), # 4
21105 
  )
21106 
 
21107 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
21108 
    self.collectedAmountMap = collectedAmountMap
21109 
    self.xferBy = xferBy
21110 
    self.xferTxnId = xferTxnId
21111 
    self.xferDate = xferDate
21112 
 
21113 
  def read(self, iprot):
21114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21116 
      return
21117 
    iprot.readStructBegin()
21118 
    while True:
21119 
      (fname, ftype, fid) = iprot.readFieldBegin()
21120 
      if ftype == TType.STOP:
21121 
        break
21122 
      if fid == 1:
21123 
        if ftype == TType.MAP:
21124 
          self.collectedAmountMap = {}
6188 rajveer 21125 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
21126 
          for _i457 in xrange(_size453):
21127 
            _key458 = iprot.readString();
21128 
            _val459 = iprot.readDouble();
21129 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 21130 
          iprot.readMapEnd()
21131 
        else:
21132 
          iprot.skip(ftype)
21133 
      elif fid == 2:
21134 
        if ftype == TType.STRING:
21135 
          self.xferBy = iprot.readString();
21136 
        else:
21137 
          iprot.skip(ftype)
21138 
      elif fid == 3:
21139 
        if ftype == TType.STRING:
21140 
          self.xferTxnId = iprot.readString();
21141 
        else:
21142 
          iprot.skip(ftype)
21143 
      elif fid == 4:
21144 
        if ftype == TType.I64:
21145 
          self.xferDate = iprot.readI64();
21146 
        else:
21147 
          iprot.skip(ftype)
21148 
      else:
21149 
        iprot.skip(ftype)
21150 
      iprot.readFieldEnd()
21151 
    iprot.readStructEnd()
21152 
 
21153 
  def write(self, oprot):
21154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21156 
      return
21157 
    oprot.writeStructBegin('reconcileCodCollection_args')
21158 
    if self.collectedAmountMap is not None:
21159 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
21160 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 21161 
      for kiter460,viter461 in self.collectedAmountMap.items():
21162 
        oprot.writeString(kiter460)
21163 
        oprot.writeDouble(viter461)
3956 chandransh 21164 
      oprot.writeMapEnd()
21165 
      oprot.writeFieldEnd()
21166 
    if self.xferBy is not None:
21167 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
21168 
      oprot.writeString(self.xferBy)
21169 
      oprot.writeFieldEnd()
21170 
    if self.xferTxnId is not None:
21171 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
21172 
      oprot.writeString(self.xferTxnId)
21173 
      oprot.writeFieldEnd()
21174 
    if self.xferDate is not None:
21175 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
21176 
      oprot.writeI64(self.xferDate)
21177 
      oprot.writeFieldEnd()
21178 
    oprot.writeFieldStop()
21179 
    oprot.writeStructEnd()
21180 
 
21181 
  def validate(self):
21182 
    return
21183 
 
21184 
 
21185 
  def __repr__(self):
21186 
    L = ['%s=%r' % (key, value)
21187 
      for key, value in self.__dict__.iteritems()]
21188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21189 
 
21190 
  def __eq__(self, other):
21191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21192 
 
21193 
  def __ne__(self, other):
21194 
    return not (self == other)
21195 
 
21196 
class reconcileCodCollection_result:
21197 
  """
21198 
  Attributes:
21199 
   - success
21200 
   - ex
21201 
  """
21202 
 
21203 
  thrift_spec = (
21204 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
21205 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21206 
  )
21207 
 
21208 
  def __init__(self, success=None, ex=None,):
21209 
    self.success = success
21210 
    self.ex = ex
21211 
 
21212 
  def read(self, iprot):
21213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21215 
      return
21216 
    iprot.readStructBegin()
21217 
    while True:
21218 
      (fname, ftype, fid) = iprot.readFieldBegin()
21219 
      if ftype == TType.STOP:
21220 
        break
21221 
      if fid == 0:
21222 
        if ftype == TType.MAP:
21223 
          self.success = {}
6188 rajveer 21224 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
21225 
          for _i466 in xrange(_size462):
21226 
            _key467 = iprot.readString();
21227 
            _val468 = iprot.readString();
21228 
            self.success[_key467] = _val468
3956 chandransh 21229 
          iprot.readMapEnd()
21230 
        else:
21231 
          iprot.skip(ftype)
21232 
      elif fid == 1:
21233 
        if ftype == TType.STRUCT:
21234 
          self.ex = TransactionServiceException()
21235 
          self.ex.read(iprot)
21236 
        else:
21237 
          iprot.skip(ftype)
21238 
      else:
21239 
        iprot.skip(ftype)
21240 
      iprot.readFieldEnd()
21241 
    iprot.readStructEnd()
21242 
 
21243 
  def write(self, oprot):
21244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21246 
      return
21247 
    oprot.writeStructBegin('reconcileCodCollection_result')
21248 
    if self.success is not None:
21249 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21250 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 21251 
      for kiter469,viter470 in self.success.items():
21252 
        oprot.writeString(kiter469)
21253 
        oprot.writeString(viter470)
3956 chandransh 21254 
      oprot.writeMapEnd()
21255 
      oprot.writeFieldEnd()
21256 
    if self.ex is not None:
21257 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21258 
      self.ex.write(oprot)
21259 
      oprot.writeFieldEnd()
21260 
    oprot.writeFieldStop()
21261 
    oprot.writeStructEnd()
21262 
 
21263 
  def validate(self):
21264 
    return
21265 
 
21266 
 
21267 
  def __repr__(self):
21268 
    L = ['%s=%r' % (key, value)
21269 
      for key, value in self.__dict__.iteritems()]
21270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21271 
 
21272 
  def __eq__(self, other):
21273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21274 
 
21275 
  def __ne__(self, other):
21276 
    return not (self == other)
4008 mandeep.dh 21277 
 
21278 
class getTransactionsRequiringExtraProcessing_args:
21279 
  """
21280 
  Attributes:
21281 
   - category
21282 
  """
21283 
 
21284 
  thrift_spec = (
21285 
    None, # 0
21286 
    (1, TType.I32, 'category', None, None, ), # 1
21287 
  )
21288 
 
21289 
  def __init__(self, category=None,):
21290 
    self.category = category
21291 
 
21292 
  def read(self, iprot):
21293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21295 
      return
21296 
    iprot.readStructBegin()
21297 
    while True:
21298 
      (fname, ftype, fid) = iprot.readFieldBegin()
21299 
      if ftype == TType.STOP:
21300 
        break
21301 
      if fid == 1:
21302 
        if ftype == TType.I32:
21303 
          self.category = iprot.readI32();
21304 
        else:
21305 
          iprot.skip(ftype)
21306 
      else:
21307 
        iprot.skip(ftype)
21308 
      iprot.readFieldEnd()
21309 
    iprot.readStructEnd()
21310 
 
21311 
  def write(self, oprot):
21312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21314 
      return
21315 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
21316 
    if self.category is not None:
21317 
      oprot.writeFieldBegin('category', TType.I32, 1)
21318 
      oprot.writeI32(self.category)
21319 
      oprot.writeFieldEnd()
21320 
    oprot.writeFieldStop()
21321 
    oprot.writeStructEnd()
21322 
 
21323 
  def validate(self):
21324 
    return
21325 
 
21326 
 
21327 
  def __repr__(self):
21328 
    L = ['%s=%r' % (key, value)
21329 
      for key, value in self.__dict__.iteritems()]
21330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21331 
 
21332 
  def __eq__(self, other):
21333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21334 
 
21335 
  def __ne__(self, other):
21336 
    return not (self == other)
21337 
 
21338 
class getTransactionsRequiringExtraProcessing_result:
21339 
  """
21340 
  Attributes:
21341 
   - success
21342 
  """
21343 
 
21344 
  thrift_spec = (
21345 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21346 
  )
21347 
 
21348 
  def __init__(self, success=None,):
21349 
    self.success = success
21350 
 
21351 
  def read(self, iprot):
21352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21354 
      return
21355 
    iprot.readStructBegin()
21356 
    while True:
21357 
      (fname, ftype, fid) = iprot.readFieldBegin()
21358 
      if ftype == TType.STOP:
21359 
        break
21360 
      if fid == 0:
21361 
        if ftype == TType.LIST:
21362 
          self.success = []
6188 rajveer 21363 
          (_etype474, _size471) = iprot.readListBegin()
21364 
          for _i475 in xrange(_size471):
21365 
            _elem476 = iprot.readI64();
21366 
            self.success.append(_elem476)
4008 mandeep.dh 21367 
          iprot.readListEnd()
21368 
        else:
21369 
          iprot.skip(ftype)
21370 
      else:
21371 
        iprot.skip(ftype)
21372 
      iprot.readFieldEnd()
21373 
    iprot.readStructEnd()
21374 
 
21375 
  def write(self, oprot):
21376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21378 
      return
21379 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
21380 
    if self.success is not None:
21381 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21382 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 21383 
      for iter477 in self.success:
21384 
        oprot.writeI64(iter477)
4008 mandeep.dh 21385 
      oprot.writeListEnd()
21386 
      oprot.writeFieldEnd()
21387 
    oprot.writeFieldStop()
21388 
    oprot.writeStructEnd()
21389 
 
21390 
  def validate(self):
21391 
    return
21392 
 
21393 
 
21394 
  def __repr__(self):
21395 
    L = ['%s=%r' % (key, value)
21396 
      for key, value in self.__dict__.iteritems()]
21397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21398 
 
21399 
  def __eq__(self, other):
21400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21401 
 
21402 
  def __ne__(self, other):
21403 
    return not (self == other)
21404 
 
21405 
class markTransactionAsProcessed_args:
21406 
  """
21407 
  Attributes:
21408 
   - transactionId
21409 
   - category
21410 
  """
21411 
 
21412 
  thrift_spec = (
21413 
    None, # 0
21414 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21415 
    (2, TType.I32, 'category', None, None, ), # 2
21416 
  )
21417 
 
21418 
  def __init__(self, transactionId=None, category=None,):
21419 
    self.transactionId = transactionId
21420 
    self.category = category
21421 
 
21422 
  def read(self, iprot):
21423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21425 
      return
21426 
    iprot.readStructBegin()
21427 
    while True:
21428 
      (fname, ftype, fid) = iprot.readFieldBegin()
21429 
      if ftype == TType.STOP:
21430 
        break
21431 
      if fid == 1:
21432 
        if ftype == TType.I64:
21433 
          self.transactionId = iprot.readI64();
21434 
        else:
21435 
          iprot.skip(ftype)
21436 
      elif fid == 2:
21437 
        if ftype == TType.I32:
21438 
          self.category = iprot.readI32();
21439 
        else:
21440 
          iprot.skip(ftype)
21441 
      else:
21442 
        iprot.skip(ftype)
21443 
      iprot.readFieldEnd()
21444 
    iprot.readStructEnd()
21445 
 
21446 
  def write(self, oprot):
21447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21449 
      return
21450 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
21451 
    if self.transactionId is not None:
21452 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21453 
      oprot.writeI64(self.transactionId)
21454 
      oprot.writeFieldEnd()
21455 
    if self.category is not None:
21456 
      oprot.writeFieldBegin('category', TType.I32, 2)
21457 
      oprot.writeI32(self.category)
21458 
      oprot.writeFieldEnd()
21459 
    oprot.writeFieldStop()
21460 
    oprot.writeStructEnd()
21461 
 
21462 
  def validate(self):
21463 
    return
21464 
 
21465 
 
21466 
  def __repr__(self):
21467 
    L = ['%s=%r' % (key, value)
21468 
      for key, value in self.__dict__.iteritems()]
21469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21470 
 
21471 
  def __eq__(self, other):
21472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21473 
 
21474 
  def __ne__(self, other):
21475 
    return not (self == other)
21476 
 
21477 
class markTransactionAsProcessed_result:
21478 
 
21479 
  thrift_spec = (
21480 
  )
21481 
 
21482 
  def read(self, iprot):
21483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21485 
      return
21486 
    iprot.readStructBegin()
21487 
    while True:
21488 
      (fname, ftype, fid) = iprot.readFieldBegin()
21489 
      if ftype == TType.STOP:
21490 
        break
21491 
      else:
21492 
        iprot.skip(ftype)
21493 
      iprot.readFieldEnd()
21494 
    iprot.readStructEnd()
21495 
 
21496 
  def write(self, oprot):
21497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21499 
      return
21500 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
21501 
    oprot.writeFieldStop()
21502 
    oprot.writeStructEnd()
21503 
 
21504 
  def validate(self):
21505 
    return
21506 
 
21507 
 
21508 
  def __repr__(self):
21509 
    L = ['%s=%r' % (key, value)
21510 
      for key, value in self.__dict__.iteritems()]
21511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21512 
 
21513 
  def __eq__(self, other):
21514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21515 
 
21516 
  def __ne__(self, other):
21517 
    return not (self == other)
4018 chandransh 21518 
 
21519 
class getItemWiseRiskyOrdersCount_args:
21520 
 
21521 
  thrift_spec = (
21522 
  )
21523 
 
21524 
  def read(self, iprot):
21525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21527 
      return
21528 
    iprot.readStructBegin()
21529 
    while True:
21530 
      (fname, ftype, fid) = iprot.readFieldBegin()
21531 
      if ftype == TType.STOP:
21532 
        break
21533 
      else:
21534 
        iprot.skip(ftype)
21535 
      iprot.readFieldEnd()
21536 
    iprot.readStructEnd()
21537 
 
21538 
  def write(self, oprot):
21539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21541 
      return
21542 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
21543 
    oprot.writeFieldStop()
21544 
    oprot.writeStructEnd()
21545 
 
21546 
  def validate(self):
21547 
    return
21548 
 
21549 
 
21550 
  def __repr__(self):
21551 
    L = ['%s=%r' % (key, value)
21552 
      for key, value in self.__dict__.iteritems()]
21553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21554 
 
21555 
  def __eq__(self, other):
21556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21557 
 
21558 
  def __ne__(self, other):
21559 
    return not (self == other)
21560 
 
21561 
class getItemWiseRiskyOrdersCount_result:
21562 
  """
21563 
  Attributes:
21564 
   - success
21565 
  """
21566 
 
21567 
  thrift_spec = (
21568 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21569 
  )
21570 
 
21571 
  def __init__(self, success=None,):
21572 
    self.success = success
21573 
 
21574 
  def read(self, iprot):
21575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21577 
      return
21578 
    iprot.readStructBegin()
21579 
    while True:
21580 
      (fname, ftype, fid) = iprot.readFieldBegin()
21581 
      if ftype == TType.STOP:
21582 
        break
21583 
      if fid == 0:
21584 
        if ftype == TType.MAP:
21585 
          self.success = {}
6188 rajveer 21586 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
21587 
          for _i482 in xrange(_size478):
21588 
            _key483 = iprot.readI64();
21589 
            _val484 = iprot.readI64();
21590 
            self.success[_key483] = _val484
4018 chandransh 21591 
          iprot.readMapEnd()
21592 
        else:
21593 
          iprot.skip(ftype)
21594 
      else:
21595 
        iprot.skip(ftype)
21596 
      iprot.readFieldEnd()
21597 
    iprot.readStructEnd()
21598 
 
21599 
  def write(self, oprot):
21600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21602 
      return
21603 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
21604 
    if self.success is not None:
21605 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21606 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 21607 
      for kiter485,viter486 in self.success.items():
21608 
        oprot.writeI64(kiter485)
21609 
        oprot.writeI64(viter486)
4018 chandransh 21610 
      oprot.writeMapEnd()
21611 
      oprot.writeFieldEnd()
21612 
    oprot.writeFieldStop()
21613 
    oprot.writeStructEnd()
21614 
 
21615 
  def validate(self):
21616 
    return
21617 
 
21618 
 
21619 
  def __repr__(self):
21620 
    L = ['%s=%r' % (key, value)
21621 
      for key, value in self.__dict__.iteritems()]
21622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21623 
 
21624 
  def __eq__(self, other):
21625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21626 
 
21627 
  def __ne__(self, other):
21628 
    return not (self == other)
4247 rajveer 21629 
 
4295 varun.gupt 21630 
class getOrdersForItemIds_args:
21631 
  """
21632 
  Attributes:
21633 
   - itemIds
21634 
  """
21635 
 
21636 
  thrift_spec = (
21637 
    None, # 0
21638 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21639 
  )
21640 
 
21641 
  def __init__(self, itemIds=None,):
21642 
    self.itemIds = itemIds
21643 
 
21644 
  def read(self, iprot):
21645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21647 
      return
21648 
    iprot.readStructBegin()
21649 
    while True:
21650 
      (fname, ftype, fid) = iprot.readFieldBegin()
21651 
      if ftype == TType.STOP:
21652 
        break
21653 
      if fid == 1:
21654 
        if ftype == TType.LIST:
21655 
          self.itemIds = []
6188 rajveer 21656 
          (_etype490, _size487) = iprot.readListBegin()
21657 
          for _i491 in xrange(_size487):
21658 
            _elem492 = iprot.readI64();
21659 
            self.itemIds.append(_elem492)
4295 varun.gupt 21660 
          iprot.readListEnd()
21661 
        else:
21662 
          iprot.skip(ftype)
21663 
      else:
21664 
        iprot.skip(ftype)
21665 
      iprot.readFieldEnd()
21666 
    iprot.readStructEnd()
21667 
 
21668 
  def write(self, oprot):
21669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21671 
      return
21672 
    oprot.writeStructBegin('getOrdersForItemIds_args')
21673 
    if self.itemIds is not None:
21674 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21675 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21676 
      for iter493 in self.itemIds:
21677 
        oprot.writeI64(iter493)
4295 varun.gupt 21678 
      oprot.writeListEnd()
21679 
      oprot.writeFieldEnd()
21680 
    oprot.writeFieldStop()
21681 
    oprot.writeStructEnd()
21682 
 
21683 
  def validate(self):
21684 
    return
21685 
 
21686 
 
21687 
  def __repr__(self):
21688 
    L = ['%s=%r' % (key, value)
21689 
      for key, value in self.__dict__.iteritems()]
21690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21691 
 
21692 
  def __eq__(self, other):
21693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21694 
 
21695 
  def __ne__(self, other):
21696 
    return not (self == other)
21697 
 
21698 
class getOrdersForItemIds_result:
21699 
  """
21700 
  Attributes:
21701 
   - success
21702 
  """
21703 
 
21704 
  thrift_spec = (
21705 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21706 
  )
21707 
 
21708 
  def __init__(self, success=None,):
21709 
    self.success = success
21710 
 
21711 
  def read(self, iprot):
21712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21714 
      return
21715 
    iprot.readStructBegin()
21716 
    while True:
21717 
      (fname, ftype, fid) = iprot.readFieldBegin()
21718 
      if ftype == TType.STOP:
21719 
        break
21720 
      if fid == 0:
21721 
        if ftype == TType.LIST:
21722 
          self.success = []
6188 rajveer 21723 
          (_etype497, _size494) = iprot.readListBegin()
21724 
          for _i498 in xrange(_size494):
21725 
            _elem499 = Order()
21726 
            _elem499.read(iprot)
21727 
            self.success.append(_elem499)
4295 varun.gupt 21728 
          iprot.readListEnd()
21729 
        else:
21730 
          iprot.skip(ftype)
21731 
      else:
21732 
        iprot.skip(ftype)
21733 
      iprot.readFieldEnd()
21734 
    iprot.readStructEnd()
21735 
 
21736 
  def write(self, oprot):
21737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21739 
      return
21740 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21741 
    if self.success is not None:
21742 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21743 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21744 
      for iter500 in self.success:
21745 
        iter500.write(oprot)
4295 varun.gupt 21746 
      oprot.writeListEnd()
21747 
      oprot.writeFieldEnd()
21748 
    oprot.writeFieldStop()
21749 
    oprot.writeStructEnd()
21750 
 
21751 
  def validate(self):
21752 
    return
21753 
 
21754 
 
21755 
  def __repr__(self):
21756 
    L = ['%s=%r' % (key, value)
21757 
      for key, value in self.__dict__.iteritems()]
21758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21759 
 
21760 
  def __eq__(self, other):
21761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21762 
 
21763 
  def __ne__(self, other):
21764 
    return not (self == other)
21765 
 
4247 rajveer 21766 
class markOrderCancellationRequestReceived_args:
21767 
  """
21768 
  Attributes:
21769 
   - orderId
21770 
  """
21771 
 
21772 
  thrift_spec = (
21773 
    None, # 0
21774 
    (1, TType.I64, 'orderId', None, None, ), # 1
21775 
  )
21776 
 
21777 
  def __init__(self, orderId=None,):
21778 
    self.orderId = orderId
21779 
 
21780 
  def read(self, iprot):
21781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21783 
      return
21784 
    iprot.readStructBegin()
21785 
    while True:
21786 
      (fname, ftype, fid) = iprot.readFieldBegin()
21787 
      if ftype == TType.STOP:
21788 
        break
21789 
      if fid == 1:
21790 
        if ftype == TType.I64:
21791 
          self.orderId = iprot.readI64();
21792 
        else:
21793 
          iprot.skip(ftype)
21794 
      else:
21795 
        iprot.skip(ftype)
21796 
      iprot.readFieldEnd()
21797 
    iprot.readStructEnd()
21798 
 
21799 
  def write(self, oprot):
21800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21802 
      return
21803 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21804 
    if self.orderId is not None:
21805 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21806 
      oprot.writeI64(self.orderId)
21807 
      oprot.writeFieldEnd()
21808 
    oprot.writeFieldStop()
21809 
    oprot.writeStructEnd()
21810 
 
21811 
  def validate(self):
21812 
    return
21813 
 
21814 
 
21815 
  def __repr__(self):
21816 
    L = ['%s=%r' % (key, value)
21817 
      for key, value in self.__dict__.iteritems()]
21818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21819 
 
21820 
  def __eq__(self, other):
21821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21822 
 
21823 
  def __ne__(self, other):
21824 
    return not (self == other)
21825 
 
21826 
class markOrderCancellationRequestReceived_result:
21827 
  """
21828 
  Attributes:
21829 
   - ex
21830 
  """
21831 
 
21832 
  thrift_spec = (
21833 
    None, # 0
21834 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21835 
  )
21836 
 
21837 
  def __init__(self, ex=None,):
21838 
    self.ex = ex
21839 
 
21840 
  def read(self, iprot):
21841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21843 
      return
21844 
    iprot.readStructBegin()
21845 
    while True:
21846 
      (fname, ftype, fid) = iprot.readFieldBegin()
21847 
      if ftype == TType.STOP:
21848 
        break
21849 
      if fid == 1:
21850 
        if ftype == TType.STRUCT:
21851 
          self.ex = TransactionServiceException()
21852 
          self.ex.read(iprot)
21853 
        else:
21854 
          iprot.skip(ftype)
21855 
      else:
21856 
        iprot.skip(ftype)
21857 
      iprot.readFieldEnd()
21858 
    iprot.readStructEnd()
21859 
 
21860 
  def write(self, oprot):
21861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21863 
      return
21864 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21865 
    if self.ex is not None:
21866 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21867 
      self.ex.write(oprot)
21868 
      oprot.writeFieldEnd()
21869 
    oprot.writeFieldStop()
21870 
    oprot.writeStructEnd()
21871 
 
21872 
  def validate(self):
21873 
    return
21874 
 
21875 
 
21876 
  def __repr__(self):
21877 
    L = ['%s=%r' % (key, value)
21878 
      for key, value in self.__dict__.iteritems()]
21879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21880 
 
21881 
  def __eq__(self, other):
21882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21883 
 
21884 
  def __ne__(self, other):
21885 
    return not (self == other)
21886 
 
21887 
class markOrderCancellationRequestConfirmed_args:
21888 
  """
21889 
  Attributes:
21890 
   - orderId
21891 
  """
21892 
 
21893 
  thrift_spec = (
21894 
    None, # 0
21895 
    (1, TType.I64, 'orderId', None, None, ), # 1
21896 
  )
21897 
 
21898 
  def __init__(self, orderId=None,):
21899 
    self.orderId = orderId
21900 
 
21901 
  def read(self, iprot):
21902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21904 
      return
21905 
    iprot.readStructBegin()
21906 
    while True:
21907 
      (fname, ftype, fid) = iprot.readFieldBegin()
21908 
      if ftype == TType.STOP:
21909 
        break
21910 
      if fid == 1:
21911 
        if ftype == TType.I64:
21912 
          self.orderId = iprot.readI64();
21913 
        else:
21914 
          iprot.skip(ftype)
21915 
      else:
21916 
        iprot.skip(ftype)
21917 
      iprot.readFieldEnd()
21918 
    iprot.readStructEnd()
21919 
 
21920 
  def write(self, oprot):
21921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21923 
      return
21924 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21925 
    if self.orderId is not None:
21926 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21927 
      oprot.writeI64(self.orderId)
21928 
      oprot.writeFieldEnd()
21929 
    oprot.writeFieldStop()
21930 
    oprot.writeStructEnd()
21931 
 
21932 
  def validate(self):
21933 
    return
21934 
 
21935 
 
21936 
  def __repr__(self):
21937 
    L = ['%s=%r' % (key, value)
21938 
      for key, value in self.__dict__.iteritems()]
21939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21940 
 
21941 
  def __eq__(self, other):
21942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21943 
 
21944 
  def __ne__(self, other):
21945 
    return not (self == other)
21946 
 
21947 
class markOrderCancellationRequestConfirmed_result:
21948 
  """
21949 
  Attributes:
21950 
   - ex
21951 
  """
21952 
 
21953 
  thrift_spec = (
21954 
    None, # 0
21955 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21956 
  )
21957 
 
21958 
  def __init__(self, ex=None,):
21959 
    self.ex = ex
21960 
 
21961 
  def read(self, iprot):
21962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21964 
      return
21965 
    iprot.readStructBegin()
21966 
    while True:
21967 
      (fname, ftype, fid) = iprot.readFieldBegin()
21968 
      if ftype == TType.STOP:
21969 
        break
21970 
      if fid == 1:
21971 
        if ftype == TType.STRUCT:
21972 
          self.ex = TransactionServiceException()
21973 
          self.ex.read(iprot)
21974 
        else:
21975 
          iprot.skip(ftype)
21976 
      else:
21977 
        iprot.skip(ftype)
21978 
      iprot.readFieldEnd()
21979 
    iprot.readStructEnd()
21980 
 
21981 
  def write(self, oprot):
21982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21984 
      return
21985 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21986 
    if self.ex is not None:
21987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21988 
      self.ex.write(oprot)
21989 
      oprot.writeFieldEnd()
21990 
    oprot.writeFieldStop()
21991 
    oprot.writeStructEnd()
21992 
 
21993 
  def validate(self):
21994 
    return
21995 
 
21996 
 
21997 
  def __repr__(self):
21998 
    L = ['%s=%r' % (key, value)
21999 
      for key, value in self.__dict__.iteritems()]
22000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22001 
 
22002 
  def __eq__(self, other):
22003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22004 
 
22005 
  def __ne__(self, other):
22006 
    return not (self == other)
22007 
 
22008 
class markOrderCancellationRequestDenied_args:
22009 
  """
22010 
  Attributes:
22011 
   - orderId
22012 
  """
22013 
 
22014 
  thrift_spec = (
22015 
    None, # 0
22016 
    (1, TType.I64, 'orderId', None, None, ), # 1
22017 
  )
22018 
 
22019 
  def __init__(self, orderId=None,):
22020 
    self.orderId = orderId
22021 
 
22022 
  def read(self, iprot):
22023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22025 
      return
22026 
    iprot.readStructBegin()
22027 
    while True:
22028 
      (fname, ftype, fid) = iprot.readFieldBegin()
22029 
      if ftype == TType.STOP:
22030 
        break
22031 
      if fid == 1:
22032 
        if ftype == TType.I64:
22033 
          self.orderId = iprot.readI64();
22034 
        else:
22035 
          iprot.skip(ftype)
22036 
      else:
22037 
        iprot.skip(ftype)
22038 
      iprot.readFieldEnd()
22039 
    iprot.readStructEnd()
22040 
 
22041 
  def write(self, oprot):
22042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22044 
      return
22045 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
22046 
    if self.orderId is not None:
22047 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22048 
      oprot.writeI64(self.orderId)
22049 
      oprot.writeFieldEnd()
22050 
    oprot.writeFieldStop()
22051 
    oprot.writeStructEnd()
22052 
 
22053 
  def validate(self):
22054 
    return
22055 
 
22056 
 
22057 
  def __repr__(self):
22058 
    L = ['%s=%r' % (key, value)
22059 
      for key, value in self.__dict__.iteritems()]
22060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22061 
 
22062 
  def __eq__(self, other):
22063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22064 
 
22065 
  def __ne__(self, other):
22066 
    return not (self == other)
22067 
 
22068 
class markOrderCancellationRequestDenied_result:
22069 
  """
22070 
  Attributes:
22071 
   - ex
22072 
  """
22073 
 
22074 
  thrift_spec = (
22075 
    None, # 0
22076 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22077 
  )
22078 
 
22079 
  def __init__(self, ex=None,):
22080 
    self.ex = ex
22081 
 
22082 
  def read(self, iprot):
22083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22085 
      return
22086 
    iprot.readStructBegin()
22087 
    while True:
22088 
      (fname, ftype, fid) = iprot.readFieldBegin()
22089 
      if ftype == TType.STOP:
22090 
        break
22091 
      if fid == 1:
22092 
        if ftype == TType.STRUCT:
22093 
          self.ex = TransactionServiceException()
22094 
          self.ex.read(iprot)
22095 
        else:
22096 
          iprot.skip(ftype)
22097 
      else:
22098 
        iprot.skip(ftype)
22099 
      iprot.readFieldEnd()
22100 
    iprot.readStructEnd()
22101 
 
22102 
  def write(self, oprot):
22103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22105 
      return
22106 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
22107 
    if self.ex is not None:
22108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22109 
      self.ex.write(oprot)
22110 
      oprot.writeFieldEnd()
22111 
    oprot.writeFieldStop()
22112 
    oprot.writeStructEnd()
22113 
 
22114 
  def validate(self):
22115 
    return
22116 
 
22117 
 
22118 
  def __repr__(self):
22119 
    L = ['%s=%r' % (key, value)
22120 
      for key, value in self.__dict__.iteritems()]
22121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22122 
 
22123 
  def __eq__(self, other):
22124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22125 
 
22126 
  def __ne__(self, other):
22127 
    return not (self == other)
22128 
 
4258 rajveer 22129 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 22130 
  """
22131 
  Attributes:
4258 rajveer 22132 
   - transactionId
4247 rajveer 22133 
  """
22134 
 
22135 
  thrift_spec = (
22136 
    None, # 0
4258 rajveer 22137 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 22138 
  )
22139 
 
4258 rajveer 22140 
  def __init__(self, transactionId=None,):
22141 
    self.transactionId = transactionId
4247 rajveer 22142 
 
22143 
  def read(self, iprot):
22144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22146 
      return
22147 
    iprot.readStructBegin()
22148 
    while True:
22149 
      (fname, ftype, fid) = iprot.readFieldBegin()
22150 
      if ftype == TType.STOP:
22151 
        break
22152 
      if fid == 1:
22153 
        if ftype == TType.I64:
4258 rajveer 22154 
          self.transactionId = iprot.readI64();
4247 rajveer 22155 
        else:
22156 
          iprot.skip(ftype)
22157 
      else:
22158 
        iprot.skip(ftype)
22159 
      iprot.readFieldEnd()
22160 
    iprot.readStructEnd()
22161 
 
22162 
  def write(self, oprot):
22163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22165 
      return
4258 rajveer 22166 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
22167 
    if self.transactionId is not None:
22168 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
22169 
      oprot.writeI64(self.transactionId)
4247 rajveer 22170 
      oprot.writeFieldEnd()
22171 
    oprot.writeFieldStop()
22172 
    oprot.writeStructEnd()
22173 
 
22174 
  def validate(self):
22175 
    return
22176 
 
22177 
 
22178 
  def __repr__(self):
22179 
    L = ['%s=%r' % (key, value)
22180 
      for key, value in self.__dict__.iteritems()]
22181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22182 
 
22183 
  def __eq__(self, other):
22184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22185 
 
22186 
  def __ne__(self, other):
22187 
    return not (self == other)
22188 
 
4258 rajveer 22189 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 22190 
  """
22191 
  Attributes:
22192 
   - ex
22193 
  """
22194 
 
22195 
  thrift_spec = (
22196 
    None, # 0
22197 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22198 
  )
22199 
 
22200 
  def __init__(self, ex=None,):
22201 
    self.ex = ex
22202 
 
22203 
  def read(self, iprot):
22204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22206 
      return
22207 
    iprot.readStructBegin()
22208 
    while True:
22209 
      (fname, ftype, fid) = iprot.readFieldBegin()
22210 
      if ftype == TType.STOP:
22211 
        break
22212 
      if fid == 1:
22213 
        if ftype == TType.STRUCT:
22214 
          self.ex = TransactionServiceException()
22215 
          self.ex.read(iprot)
22216 
        else:
22217 
          iprot.skip(ftype)
22218 
      else:
22219 
        iprot.skip(ftype)
22220 
      iprot.readFieldEnd()
22221 
    iprot.readStructEnd()
22222 
 
22223 
  def write(self, oprot):
22224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22226 
      return
4258 rajveer 22227 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 22228 
    if self.ex is not None:
22229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22230 
      self.ex.write(oprot)
22231 
      oprot.writeFieldEnd()
22232 
    oprot.writeFieldStop()
22233 
    oprot.writeStructEnd()
22234 
 
22235 
  def validate(self):
22236 
    return
22237 
 
22238 
 
22239 
  def __repr__(self):
22240 
    L = ['%s=%r' % (key, value)
22241 
      for key, value in self.__dict__.iteritems()]
22242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22243 
 
22244 
  def __eq__(self, other):
22245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22246 
 
22247 
  def __ne__(self, other):
22248 
    return not (self == other)
4259 anupam.sin 22249 
 
22250 
class refundTransaction_args:
22251 
  """
22252 
  Attributes:
22253 
   - transactionId
22254 
   - refundedBy
22255 
   - reason
22256 
  """
22257 
 
22258 
  thrift_spec = (
22259 
    None, # 0
22260 
    (1, TType.I64, 'transactionId', None, None, ), # 1
22261 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
22262 
    (3, TType.STRING, 'reason', None, None, ), # 3
22263 
  )
22264 
 
22265 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
22266 
    self.transactionId = transactionId
22267 
    self.refundedBy = refundedBy
22268 
    self.reason = reason
22269 
 
22270 
  def read(self, iprot):
22271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22273 
      return
22274 
    iprot.readStructBegin()
22275 
    while True:
22276 
      (fname, ftype, fid) = iprot.readFieldBegin()
22277 
      if ftype == TType.STOP:
22278 
        break
22279 
      if fid == 1:
22280 
        if ftype == TType.I64:
22281 
          self.transactionId = iprot.readI64();
22282 
        else:
22283 
          iprot.skip(ftype)
22284 
      elif fid == 2:
22285 
        if ftype == TType.STRING:
22286 
          self.refundedBy = iprot.readString();
22287 
        else:
22288 
          iprot.skip(ftype)
22289 
      elif fid == 3:
22290 
        if ftype == TType.STRING:
22291 
          self.reason = iprot.readString();
22292 
        else:
22293 
          iprot.skip(ftype)
22294 
      else:
22295 
        iprot.skip(ftype)
22296 
      iprot.readFieldEnd()
22297 
    iprot.readStructEnd()
22298 
 
22299 
  def write(self, oprot):
22300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22302 
      return
22303 
    oprot.writeStructBegin('refundTransaction_args')
22304 
    if self.transactionId is not None:
22305 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
22306 
      oprot.writeI64(self.transactionId)
22307 
      oprot.writeFieldEnd()
22308 
    if self.refundedBy is not None:
22309 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
22310 
      oprot.writeString(self.refundedBy)
22311 
      oprot.writeFieldEnd()
22312 
    if self.reason is not None:
22313 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
22314 
      oprot.writeString(self.reason)
22315 
      oprot.writeFieldEnd()
22316 
    oprot.writeFieldStop()
22317 
    oprot.writeStructEnd()
22318 
 
22319 
  def validate(self):
22320 
    return
22321 
 
22322 
 
22323 
  def __repr__(self):
22324 
    L = ['%s=%r' % (key, value)
22325 
      for key, value in self.__dict__.iteritems()]
22326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22327 
 
22328 
  def __eq__(self, other):
22329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22330 
 
22331 
  def __ne__(self, other):
22332 
    return not (self == other)
22333 
 
22334 
class refundTransaction_result:
22335 
  """
22336 
  Attributes:
22337 
   - ex
22338 
  """
22339 
 
22340 
  thrift_spec = (
22341 
    None, # 0
22342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22343 
  )
22344 
 
22345 
  def __init__(self, ex=None,):
22346 
    self.ex = ex
22347 
 
22348 
  def read(self, iprot):
22349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22351 
      return
22352 
    iprot.readStructBegin()
22353 
    while True:
22354 
      (fname, ftype, fid) = iprot.readFieldBegin()
22355 
      if ftype == TType.STOP:
22356 
        break
22357 
      if fid == 1:
22358 
        if ftype == TType.STRUCT:
22359 
          self.ex = TransactionServiceException()
22360 
          self.ex.read(iprot)
22361 
        else:
22362 
          iprot.skip(ftype)
22363 
      else:
22364 
        iprot.skip(ftype)
22365 
      iprot.readFieldEnd()
22366 
    iprot.readStructEnd()
22367 
 
22368 
  def write(self, oprot):
22369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22371 
      return
22372 
    oprot.writeStructBegin('refundTransaction_result')
22373 
    if self.ex is not None:
22374 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22375 
      self.ex.write(oprot)
22376 
      oprot.writeFieldEnd()
22377 
    oprot.writeFieldStop()
22378 
    oprot.writeStructEnd()
22379 
 
22380 
  def validate(self):
22381 
    return
22382 
 
22383 
 
22384 
  def __repr__(self):
22385 
    L = ['%s=%r' % (key, value)
22386 
      for key, value in self.__dict__.iteritems()]
22387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22388 
 
22389 
  def __eq__(self, other):
22390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22391 
 
22392 
  def __ne__(self, other):
22393 
    return not (self == other)
4285 rajveer 22394 
 
4324 mandeep.dh 22395 
class updateShipmentAddress_args:
22396 
  """
22397 
  Attributes:
22398 
   - orderId
22399 
   - addressId
22400 
  """
22401 
 
22402 
  thrift_spec = (
22403 
    None, # 0
22404 
    (1, TType.I64, 'orderId', None, None, ), # 1
22405 
    (2, TType.I64, 'addressId', None, None, ), # 2
22406 
  )
22407 
 
22408 
  def __init__(self, orderId=None, addressId=None,):
22409 
    self.orderId = orderId
22410 
    self.addressId = addressId
22411 
 
22412 
  def read(self, iprot):
22413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22415 
      return
22416 
    iprot.readStructBegin()
22417 
    while True:
22418 
      (fname, ftype, fid) = iprot.readFieldBegin()
22419 
      if ftype == TType.STOP:
22420 
        break
22421 
      if fid == 1:
22422 
        if ftype == TType.I64:
22423 
          self.orderId = iprot.readI64();
22424 
        else:
22425 
          iprot.skip(ftype)
22426 
      elif fid == 2:
22427 
        if ftype == TType.I64:
22428 
          self.addressId = iprot.readI64();
22429 
        else:
22430 
          iprot.skip(ftype)
22431 
      else:
22432 
        iprot.skip(ftype)
22433 
      iprot.readFieldEnd()
22434 
    iprot.readStructEnd()
22435 
 
22436 
  def write(self, oprot):
22437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22439 
      return
22440 
    oprot.writeStructBegin('updateShipmentAddress_args')
22441 
    if self.orderId is not None:
22442 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22443 
      oprot.writeI64(self.orderId)
22444 
      oprot.writeFieldEnd()
22445 
    if self.addressId is not None:
22446 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
22447 
      oprot.writeI64(self.addressId)
22448 
      oprot.writeFieldEnd()
22449 
    oprot.writeFieldStop()
22450 
    oprot.writeStructEnd()
22451 
 
22452 
  def validate(self):
22453 
    return
22454 
 
22455 
 
22456 
  def __repr__(self):
22457 
    L = ['%s=%r' % (key, value)
22458 
      for key, value in self.__dict__.iteritems()]
22459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22460 
 
22461 
  def __eq__(self, other):
22462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22463 
 
22464 
  def __ne__(self, other):
22465 
    return not (self == other)
22466 
 
22467 
class updateShipmentAddress_result:
22468 
  """
22469 
  Attributes:
22470 
   - ex
22471 
  """
22472 
 
22473 
  thrift_spec = (
22474 
    None, # 0
22475 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22476 
  )
22477 
 
22478 
  def __init__(self, ex=None,):
22479 
    self.ex = ex
22480 
 
22481 
  def read(self, iprot):
22482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22484 
      return
22485 
    iprot.readStructBegin()
22486 
    while True:
22487 
      (fname, ftype, fid) = iprot.readFieldBegin()
22488 
      if ftype == TType.STOP:
22489 
        break
22490 
      if fid == 1:
22491 
        if ftype == TType.STRUCT:
22492 
          self.ex = TransactionServiceException()
22493 
          self.ex.read(iprot)
22494 
        else:
22495 
          iprot.skip(ftype)
22496 
      else:
22497 
        iprot.skip(ftype)
22498 
      iprot.readFieldEnd()
22499 
    iprot.readStructEnd()
22500 
 
22501 
  def write(self, oprot):
22502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22504 
      return
22505 
    oprot.writeStructBegin('updateShipmentAddress_result')
22506 
    if self.ex is not None:
22507 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22508 
      self.ex.write(oprot)
22509 
      oprot.writeFieldEnd()
22510 
    oprot.writeFieldStop()
22511 
    oprot.writeStructEnd()
22512 
 
22513 
  def validate(self):
22514 
    return
22515 
 
22516 
 
22517 
  def __repr__(self):
22518 
    L = ['%s=%r' % (key, value)
22519 
      for key, value in self.__dict__.iteritems()]
22520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22521 
 
22522 
  def __eq__(self, other):
22523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22524 
 
22525 
  def __ne__(self, other):
22526 
    return not (self == other)
22527 
 
4285 rajveer 22528 
class acceptOrdersForItemId_args:
22529 
  """
22530 
  Attributes:
22531 
   - itemId
22532 
   - inventory
22533 
  """
22534 
 
22535 
  thrift_spec = (
22536 
    None, # 0
22537 
    (1, TType.I64, 'itemId', None, None, ), # 1
22538 
    (2, TType.I64, 'inventory', None, None, ), # 2
22539 
  )
22540 
 
22541 
  def __init__(self, itemId=None, inventory=None,):
22542 
    self.itemId = itemId
22543 
    self.inventory = inventory
22544 
 
22545 
  def read(self, iprot):
22546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22548 
      return
22549 
    iprot.readStructBegin()
22550 
    while True:
22551 
      (fname, ftype, fid) = iprot.readFieldBegin()
22552 
      if ftype == TType.STOP:
22553 
        break
22554 
      if fid == 1:
22555 
        if ftype == TType.I64:
22556 
          self.itemId = iprot.readI64();
22557 
        else:
22558 
          iprot.skip(ftype)
22559 
      elif fid == 2:
22560 
        if ftype == TType.I64:
22561 
          self.inventory = iprot.readI64();
22562 
        else:
22563 
          iprot.skip(ftype)
22564 
      else:
22565 
        iprot.skip(ftype)
22566 
      iprot.readFieldEnd()
22567 
    iprot.readStructEnd()
22568 
 
22569 
  def write(self, oprot):
22570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22572 
      return
22573 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
22574 
    if self.itemId is not None:
22575 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22576 
      oprot.writeI64(self.itemId)
22577 
      oprot.writeFieldEnd()
22578 
    if self.inventory is not None:
22579 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
22580 
      oprot.writeI64(self.inventory)
22581 
      oprot.writeFieldEnd()
22582 
    oprot.writeFieldStop()
22583 
    oprot.writeStructEnd()
22584 
 
22585 
  def validate(self):
22586 
    return
22587 
 
22588 
 
22589 
  def __repr__(self):
22590 
    L = ['%s=%r' % (key, value)
22591 
      for key, value in self.__dict__.iteritems()]
22592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22593 
 
22594 
  def __eq__(self, other):
22595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22596 
 
22597 
  def __ne__(self, other):
22598 
    return not (self == other)
22599 
 
22600 
class acceptOrdersForItemId_result:
22601 
  """
22602 
  Attributes:
22603 
   - success
22604 
   - ex
22605 
  """
22606 
 
22607 
  thrift_spec = (
22608 
    (0, TType.BOOL, 'success', None, None, ), # 0
22609 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22610 
  )
22611 
 
22612 
  def __init__(self, success=None, ex=None,):
22613 
    self.success = success
22614 
    self.ex = ex
22615 
 
22616 
  def read(self, iprot):
22617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22619 
      return
22620 
    iprot.readStructBegin()
22621 
    while True:
22622 
      (fname, ftype, fid) = iprot.readFieldBegin()
22623 
      if ftype == TType.STOP:
22624 
        break
22625 
      if fid == 0:
22626 
        if ftype == TType.BOOL:
22627 
          self.success = iprot.readBool();
22628 
        else:
22629 
          iprot.skip(ftype)
22630 
      elif fid == 1:
22631 
        if ftype == TType.STRUCT:
22632 
          self.ex = TransactionServiceException()
22633 
          self.ex.read(iprot)
22634 
        else:
22635 
          iprot.skip(ftype)
22636 
      else:
22637 
        iprot.skip(ftype)
22638 
      iprot.readFieldEnd()
22639 
    iprot.readStructEnd()
22640 
 
22641 
  def write(self, oprot):
22642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22644 
      return
22645 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
22646 
    if self.success is not None:
22647 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22648 
      oprot.writeBool(self.success)
22649 
      oprot.writeFieldEnd()
22650 
    if self.ex is not None:
22651 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22652 
      self.ex.write(oprot)
22653 
      oprot.writeFieldEnd()
22654 
    oprot.writeFieldStop()
22655 
    oprot.writeStructEnd()
22656 
 
22657 
  def validate(self):
22658 
    return
22659 
 
22660 
 
22661 
  def __repr__(self):
22662 
    L = ['%s=%r' % (key, value)
22663 
      for key, value in self.__dict__.iteritems()]
22664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22665 
 
22666 
  def __eq__(self, other):
22667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22668 
 
22669 
  def __ne__(self, other):
22670 
    return not (self == other)
4303 rajveer 22671 
 
22672 
class markOrdersAsPORaised_args:
22673 
  """
22674 
  Attributes:
22675 
   - vendorId
22676 
   - itemId
22677 
   - quantity
22678 
   - estimate
4369 rajveer 22679 
   - isReminder
4303 rajveer 22680 
  """
22681 
 
22682 
  thrift_spec = (
22683 
    None, # 0
22684 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22685 
    (2, TType.I64, 'itemId', None, None, ), # 2
22686 
    (3, TType.I64, 'quantity', None, None, ), # 3
22687 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22688 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22689 
  )
22690 
 
4369 rajveer 22691 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22692 
    self.vendorId = vendorId
22693 
    self.itemId = itemId
22694 
    self.quantity = quantity
22695 
    self.estimate = estimate
4369 rajveer 22696 
    self.isReminder = isReminder
4303 rajveer 22697 
 
22698 
  def read(self, iprot):
22699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22701 
      return
22702 
    iprot.readStructBegin()
22703 
    while True:
22704 
      (fname, ftype, fid) = iprot.readFieldBegin()
22705 
      if ftype == TType.STOP:
22706 
        break
22707 
      if fid == 1:
22708 
        if ftype == TType.I64:
22709 
          self.vendorId = iprot.readI64();
22710 
        else:
22711 
          iprot.skip(ftype)
22712 
      elif fid == 2:
22713 
        if ftype == TType.I64:
22714 
          self.itemId = iprot.readI64();
22715 
        else:
22716 
          iprot.skip(ftype)
22717 
      elif fid == 3:
22718 
        if ftype == TType.I64:
22719 
          self.quantity = iprot.readI64();
22720 
        else:
22721 
          iprot.skip(ftype)
22722 
      elif fid == 4:
22723 
        if ftype == TType.I64:
22724 
          self.estimate = iprot.readI64();
22725 
        else:
22726 
          iprot.skip(ftype)
4369 rajveer 22727 
      elif fid == 5:
22728 
        if ftype == TType.BOOL:
22729 
          self.isReminder = iprot.readBool();
22730 
        else:
22731 
          iprot.skip(ftype)
4303 rajveer 22732 
      else:
22733 
        iprot.skip(ftype)
22734 
      iprot.readFieldEnd()
22735 
    iprot.readStructEnd()
22736 
 
22737 
  def write(self, oprot):
22738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22740 
      return
22741 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22742 
    if self.vendorId is not None:
22743 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22744 
      oprot.writeI64(self.vendorId)
22745 
      oprot.writeFieldEnd()
22746 
    if self.itemId is not None:
22747 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22748 
      oprot.writeI64(self.itemId)
22749 
      oprot.writeFieldEnd()
22750 
    if self.quantity is not None:
22751 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22752 
      oprot.writeI64(self.quantity)
22753 
      oprot.writeFieldEnd()
22754 
    if self.estimate is not None:
22755 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22756 
      oprot.writeI64(self.estimate)
22757 
      oprot.writeFieldEnd()
4369 rajveer 22758 
    if self.isReminder is not None:
22759 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22760 
      oprot.writeBool(self.isReminder)
22761 
      oprot.writeFieldEnd()
4303 rajveer 22762 
    oprot.writeFieldStop()
22763 
    oprot.writeStructEnd()
22764 
 
22765 
  def validate(self):
22766 
    return
22767 
 
22768 
 
22769 
  def __repr__(self):
22770 
    L = ['%s=%r' % (key, value)
22771 
      for key, value in self.__dict__.iteritems()]
22772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22773 
 
22774 
  def __eq__(self, other):
22775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22776 
 
22777 
  def __ne__(self, other):
22778 
    return not (self == other)
22779 
 
22780 
class markOrdersAsPORaised_result:
22781 
  """
22782 
  Attributes:
22783 
   - ex
22784 
  """
22785 
 
22786 
  thrift_spec = (
22787 
    None, # 0
22788 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22789 
  )
22790 
 
22791 
  def __init__(self, ex=None,):
22792 
    self.ex = ex
22793 
 
22794 
  def read(self, iprot):
22795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22797 
      return
22798 
    iprot.readStructBegin()
22799 
    while True:
22800 
      (fname, ftype, fid) = iprot.readFieldBegin()
22801 
      if ftype == TType.STOP:
22802 
        break
22803 
      if fid == 1:
22804 
        if ftype == TType.STRUCT:
22805 
          self.ex = TransactionServiceException()
22806 
          self.ex.read(iprot)
22807 
        else:
22808 
          iprot.skip(ftype)
22809 
      else:
22810 
        iprot.skip(ftype)
22811 
      iprot.readFieldEnd()
22812 
    iprot.readStructEnd()
22813 
 
22814 
  def write(self, oprot):
22815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22817 
      return
22818 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22819 
    if self.ex is not None:
22820 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22821 
      self.ex.write(oprot)
22822 
      oprot.writeFieldEnd()
22823 
    oprot.writeFieldStop()
22824 
    oprot.writeStructEnd()
22825 
 
22826 
  def validate(self):
22827 
    return
22828 
 
22829 
 
22830 
  def __repr__(self):
22831 
    L = ['%s=%r' % (key, value)
22832 
      for key, value in self.__dict__.iteritems()]
22833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22834 
 
22835 
  def __eq__(self, other):
22836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22837 
 
22838 
  def __ne__(self, other):
22839 
    return not (self == other)
22840 
 
22841 
class markOrdersAsReversalInitiated_args:
22842 
  """
22843 
  Attributes:
22844 
   - vendorId
22845 
   - itemId
22846 
   - quantity
22847 
   - estimate
4369 rajveer 22848 
   - isReminder
4303 rajveer 22849 
  """
22850 
 
22851 
  thrift_spec = (
22852 
    None, # 0
22853 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22854 
    (2, TType.I64, 'itemId', None, None, ), # 2
22855 
    (3, TType.I64, 'quantity', None, None, ), # 3
22856 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22857 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22858 
  )
22859 
 
4369 rajveer 22860 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22861 
    self.vendorId = vendorId
22862 
    self.itemId = itemId
22863 
    self.quantity = quantity
22864 
    self.estimate = estimate
4369 rajveer 22865 
    self.isReminder = isReminder
4303 rajveer 22866 
 
22867 
  def read(self, iprot):
22868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22870 
      return
22871 
    iprot.readStructBegin()
22872 
    while True:
22873 
      (fname, ftype, fid) = iprot.readFieldBegin()
22874 
      if ftype == TType.STOP:
22875 
        break
22876 
      if fid == 1:
22877 
        if ftype == TType.I64:
22878 
          self.vendorId = iprot.readI64();
22879 
        else:
22880 
          iprot.skip(ftype)
22881 
      elif fid == 2:
22882 
        if ftype == TType.I64:
22883 
          self.itemId = iprot.readI64();
22884 
        else:
22885 
          iprot.skip(ftype)
22886 
      elif fid == 3:
22887 
        if ftype == TType.I64:
22888 
          self.quantity = iprot.readI64();
22889 
        else:
22890 
          iprot.skip(ftype)
22891 
      elif fid == 4:
22892 
        if ftype == TType.I64:
22893 
          self.estimate = iprot.readI64();
22894 
        else:
22895 
          iprot.skip(ftype)
4369 rajveer 22896 
      elif fid == 5:
22897 
        if ftype == TType.BOOL:
22898 
          self.isReminder = iprot.readBool();
22899 
        else:
22900 
          iprot.skip(ftype)
4303 rajveer 22901 
      else:
22902 
        iprot.skip(ftype)
22903 
      iprot.readFieldEnd()
22904 
    iprot.readStructEnd()
22905 
 
22906 
  def write(self, oprot):
22907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22909 
      return
22910 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22911 
    if self.vendorId is not None:
22912 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22913 
      oprot.writeI64(self.vendorId)
22914 
      oprot.writeFieldEnd()
22915 
    if self.itemId is not None:
22916 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22917 
      oprot.writeI64(self.itemId)
22918 
      oprot.writeFieldEnd()
22919 
    if self.quantity is not None:
22920 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22921 
      oprot.writeI64(self.quantity)
22922 
      oprot.writeFieldEnd()
22923 
    if self.estimate is not None:
22924 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22925 
      oprot.writeI64(self.estimate)
22926 
      oprot.writeFieldEnd()
4369 rajveer 22927 
    if self.isReminder is not None:
22928 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22929 
      oprot.writeBool(self.isReminder)
22930 
      oprot.writeFieldEnd()
4303 rajveer 22931 
    oprot.writeFieldStop()
22932 
    oprot.writeStructEnd()
22933 
 
22934 
  def validate(self):
22935 
    return
22936 
 
22937 
 
22938 
  def __repr__(self):
22939 
    L = ['%s=%r' % (key, value)
22940 
      for key, value in self.__dict__.iteritems()]
22941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22942 
 
22943 
  def __eq__(self, other):
22944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22945 
 
22946 
  def __ne__(self, other):
22947 
    return not (self == other)
22948 
 
22949 
class markOrdersAsReversalInitiated_result:
22950 
  """
22951 
  Attributes:
22952 
   - ex
22953 
  """
22954 
 
22955 
  thrift_spec = (
22956 
    None, # 0
22957 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22958 
  )
22959 
 
22960 
  def __init__(self, ex=None,):
22961 
    self.ex = ex
22962 
 
22963 
  def read(self, iprot):
22964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22966 
      return
22967 
    iprot.readStructBegin()
22968 
    while True:
22969 
      (fname, ftype, fid) = iprot.readFieldBegin()
22970 
      if ftype == TType.STOP:
22971 
        break
22972 
      if fid == 1:
22973 
        if ftype == TType.STRUCT:
22974 
          self.ex = TransactionServiceException()
22975 
          self.ex.read(iprot)
22976 
        else:
22977 
          iprot.skip(ftype)
22978 
      else:
22979 
        iprot.skip(ftype)
22980 
      iprot.readFieldEnd()
22981 
    iprot.readStructEnd()
22982 
 
22983 
  def write(self, oprot):
22984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22986 
      return
22987 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22988 
    if self.ex is not None:
22989 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22990 
      self.ex.write(oprot)
22991 
      oprot.writeFieldEnd()
22992 
    oprot.writeFieldStop()
22993 
    oprot.writeStructEnd()
22994 
 
22995 
  def validate(self):
22996 
    return
22997 
 
22998 
 
22999 
  def __repr__(self):
23000 
    L = ['%s=%r' % (key, value)
23001 
      for key, value in self.__dict__.iteritems()]
23002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23003 
 
23004 
  def __eq__(self, other):
23005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23006 
 
23007 
  def __ne__(self, other):
23008 
    return not (self == other)
23009 
 
23010 
class markOrdersAsNotAvailabke_args:
23011 
  """
23012 
  Attributes:
23013 
   - vendorId
23014 
   - itemId
23015 
   - quantity
23016 
   - estimate
4369 rajveer 23017 
   - isReminder
4303 rajveer 23018 
  """
23019 
 
23020 
  thrift_spec = (
23021 
    None, # 0
23022 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23023 
    (2, TType.I64, 'itemId', None, None, ), # 2
23024 
    (3, TType.I64, 'quantity', None, None, ), # 3
23025 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 23026 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 23027 
  )
23028 
 
4369 rajveer 23029 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 23030 
    self.vendorId = vendorId
23031 
    self.itemId = itemId
23032 
    self.quantity = quantity
23033 
    self.estimate = estimate
4369 rajveer 23034 
    self.isReminder = isReminder
4303 rajveer 23035 
 
23036 
  def read(self, iprot):
23037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23039 
      return
23040 
    iprot.readStructBegin()
23041 
    while True:
23042 
      (fname, ftype, fid) = iprot.readFieldBegin()
23043 
      if ftype == TType.STOP:
23044 
        break
23045 
      if fid == 1:
23046 
        if ftype == TType.I64:
23047 
          self.vendorId = iprot.readI64();
23048 
        else:
23049 
          iprot.skip(ftype)
23050 
      elif fid == 2:
23051 
        if ftype == TType.I64:
23052 
          self.itemId = iprot.readI64();
23053 
        else:
23054 
          iprot.skip(ftype)
23055 
      elif fid == 3:
23056 
        if ftype == TType.I64:
23057 
          self.quantity = iprot.readI64();
23058 
        else:
23059 
          iprot.skip(ftype)
23060 
      elif fid == 4:
23061 
        if ftype == TType.I64:
23062 
          self.estimate = iprot.readI64();
23063 
        else:
23064 
          iprot.skip(ftype)
4369 rajveer 23065 
      elif fid == 5:
23066 
        if ftype == TType.BOOL:
23067 
          self.isReminder = iprot.readBool();
23068 
        else:
23069 
          iprot.skip(ftype)
4303 rajveer 23070 
      else:
23071 
        iprot.skip(ftype)
23072 
      iprot.readFieldEnd()
23073 
    iprot.readStructEnd()
23074 
 
23075 
  def write(self, oprot):
23076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23078 
      return
23079 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
23080 
    if self.vendorId is not None:
23081 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23082 
      oprot.writeI64(self.vendorId)
23083 
      oprot.writeFieldEnd()
23084 
    if self.itemId is not None:
23085 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
23086 
      oprot.writeI64(self.itemId)
23087 
      oprot.writeFieldEnd()
23088 
    if self.quantity is not None:
23089 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
23090 
      oprot.writeI64(self.quantity)
23091 
      oprot.writeFieldEnd()
23092 
    if self.estimate is not None:
23093 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
23094 
      oprot.writeI64(self.estimate)
23095 
      oprot.writeFieldEnd()
4369 rajveer 23096 
    if self.isReminder is not None:
23097 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
23098 
      oprot.writeBool(self.isReminder)
23099 
      oprot.writeFieldEnd()
4303 rajveer 23100 
    oprot.writeFieldStop()
23101 
    oprot.writeStructEnd()
23102 
 
23103 
  def validate(self):
23104 
    return
23105 
 
23106 
 
23107 
  def __repr__(self):
23108 
    L = ['%s=%r' % (key, value)
23109 
      for key, value in self.__dict__.iteritems()]
23110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23111 
 
23112 
  def __eq__(self, other):
23113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23114 
 
23115 
  def __ne__(self, other):
23116 
    return not (self == other)
23117 
 
23118 
class markOrdersAsNotAvailabke_result:
23119 
  """
23120 
  Attributes:
23121 
   - ex
23122 
  """
23123 
 
23124 
  thrift_spec = (
23125 
    None, # 0
23126 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23127 
  )
23128 
 
23129 
  def __init__(self, ex=None,):
23130 
    self.ex = ex
23131 
 
23132 
  def read(self, iprot):
23133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23135 
      return
23136 
    iprot.readStructBegin()
23137 
    while True:
23138 
      (fname, ftype, fid) = iprot.readFieldBegin()
23139 
      if ftype == TType.STOP:
23140 
        break
23141 
      if fid == 1:
23142 
        if ftype == TType.STRUCT:
23143 
          self.ex = TransactionServiceException()
23144 
          self.ex.read(iprot)
23145 
        else:
23146 
          iprot.skip(ftype)
23147 
      else:
23148 
        iprot.skip(ftype)
23149 
      iprot.readFieldEnd()
23150 
    iprot.readStructEnd()
23151 
 
23152 
  def write(self, oprot):
23153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23155 
      return
23156 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
23157 
    if self.ex is not None:
23158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23159 
      self.ex.write(oprot)
23160 
      oprot.writeFieldEnd()
23161 
    oprot.writeFieldStop()
23162 
    oprot.writeStructEnd()
23163 
 
23164 
  def validate(self):
23165 
    return
23166 
 
23167 
 
23168 
  def __repr__(self):
23169 
    L = ['%s=%r' % (key, value)
23170 
      for key, value in self.__dict__.iteritems()]
23171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23172 
 
23173 
  def __eq__(self, other):
23174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23175 
 
23176 
  def __ne__(self, other):
23177 
    return not (self == other)
4369 rajveer 23178 
 
23179 
class markOrdersAsTimeout_args:
23180 
  """
23181 
  Attributes:
23182 
   - vendorId
23183 
  """
23184 
 
23185 
  thrift_spec = (
23186 
    None, # 0
23187 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23188 
  )
23189 
 
23190 
  def __init__(self, vendorId=None,):
23191 
    self.vendorId = vendorId
23192 
 
23193 
  def read(self, iprot):
23194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23196 
      return
23197 
    iprot.readStructBegin()
23198 
    while True:
23199 
      (fname, ftype, fid) = iprot.readFieldBegin()
23200 
      if ftype == TType.STOP:
23201 
        break
23202 
      if fid == 1:
23203 
        if ftype == TType.I64:
23204 
          self.vendorId = iprot.readI64();
23205 
        else:
23206 
          iprot.skip(ftype)
23207 
      else:
23208 
        iprot.skip(ftype)
23209 
      iprot.readFieldEnd()
23210 
    iprot.readStructEnd()
23211 
 
23212 
  def write(self, oprot):
23213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23215 
      return
23216 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
23217 
    if self.vendorId is not None:
23218 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23219 
      oprot.writeI64(self.vendorId)
23220 
      oprot.writeFieldEnd()
23221 
    oprot.writeFieldStop()
23222 
    oprot.writeStructEnd()
23223 
 
23224 
  def validate(self):
23225 
    return
23226 
 
23227 
 
23228 
  def __repr__(self):
23229 
    L = ['%s=%r' % (key, value)
23230 
      for key, value in self.__dict__.iteritems()]
23231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23232 
 
23233 
  def __eq__(self, other):
23234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23235 
 
23236 
  def __ne__(self, other):
23237 
    return not (self == other)
23238 
 
23239 
class markOrdersAsTimeout_result:
23240 
  """
23241 
  Attributes:
23242 
   - success
23243 
   - ex
23244 
  """
23245 
 
23246 
  thrift_spec = (
23247 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
23248 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23249 
  )
23250 
 
23251 
  def __init__(self, success=None, ex=None,):
23252 
    self.success = success
23253 
    self.ex = ex
23254 
 
23255 
  def read(self, iprot):
23256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23258 
      return
23259 
    iprot.readStructBegin()
23260 
    while True:
23261 
      (fname, ftype, fid) = iprot.readFieldBegin()
23262 
      if ftype == TType.STOP:
23263 
        break
23264 
      if fid == 0:
23265 
        if ftype == TType.MAP:
23266 
          self.success = {}
6188 rajveer 23267 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
23268 
          for _i505 in xrange(_size501):
23269 
            _key506 = iprot.readI32();
23270 
            _val507 = TimeoutSummary()
23271 
            _val507.read(iprot)
23272 
            self.success[_key506] = _val507
4369 rajveer 23273 
          iprot.readMapEnd()
23274 
        else:
23275 
          iprot.skip(ftype)
23276 
      elif fid == 1:
23277 
        if ftype == TType.STRUCT:
23278 
          self.ex = TransactionServiceException()
23279 
          self.ex.read(iprot)
23280 
        else:
23281 
          iprot.skip(ftype)
23282 
      else:
23283 
        iprot.skip(ftype)
23284 
      iprot.readFieldEnd()
23285 
    iprot.readStructEnd()
23286 
 
23287 
  def write(self, oprot):
23288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23290 
      return
23291 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
23292 
    if self.success is not None:
23293 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23294 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 23295 
      for kiter508,viter509 in self.success.items():
23296 
        oprot.writeI32(kiter508)
23297 
        viter509.write(oprot)
4369 rajveer 23298 
      oprot.writeMapEnd()
23299 
      oprot.writeFieldEnd()
23300 
    if self.ex is not None:
23301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23302 
      self.ex.write(oprot)
23303 
      oprot.writeFieldEnd()
23304 
    oprot.writeFieldStop()
23305 
    oprot.writeStructEnd()
23306 
 
23307 
  def validate(self):
23308 
    return
23309 
 
23310 
 
23311 
  def __repr__(self):
23312 
    L = ['%s=%r' % (key, value)
23313 
      for key, value in self.__dict__.iteritems()]
23314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23315 
 
23316 
  def __eq__(self, other):
23317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23318 
 
23319 
  def __ne__(self, other):
23320 
    return not (self == other)
4386 anupam.sin 23321 
 
4662 rajveer 23322 
class markOrderAsLostInTransit_args:
23323 
  """
23324 
  Attributes:
23325 
   - orderId
23326 
  """
23327 
 
23328 
  thrift_spec = (
23329 
    None, # 0
23330 
    (1, TType.I64, 'orderId', None, None, ), # 1
23331 
  )
23332 
 
23333 
  def __init__(self, orderId=None,):
23334 
    self.orderId = orderId
23335 
 
23336 
  def read(self, iprot):
23337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23339 
      return
23340 
    iprot.readStructBegin()
23341 
    while True:
23342 
      (fname, ftype, fid) = iprot.readFieldBegin()
23343 
      if ftype == TType.STOP:
23344 
        break
23345 
      if fid == 1:
23346 
        if ftype == TType.I64:
23347 
          self.orderId = iprot.readI64();
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('markOrderAsLostInTransit_args')
23360 
    if self.orderId is not None:
23361 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23362 
      oprot.writeI64(self.orderId)
23363 
      oprot.writeFieldEnd()
23364 
    oprot.writeFieldStop()
23365 
    oprot.writeStructEnd()
23366 
 
23367 
  def validate(self):
23368 
    return
23369 
 
23370 
 
23371 
  def __repr__(self):
23372 
    L = ['%s=%r' % (key, value)
23373 
      for key, value in self.__dict__.iteritems()]
23374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23375 
 
23376 
  def __eq__(self, other):
23377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23378 
 
23379 
  def __ne__(self, other):
23380 
    return not (self == other)
23381 
 
23382 
class markOrderAsLostInTransit_result:
23383 
  """
23384 
  Attributes:
23385 
   - success
23386 
   - ex
23387 
  """
23388 
 
23389 
  thrift_spec = (
23390 
    (0, TType.BOOL, 'success', None, None, ), # 0
23391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23392 
  )
23393 
 
23394 
  def __init__(self, success=None, ex=None,):
23395 
    self.success = success
23396 
    self.ex = ex
23397 
 
23398 
  def read(self, iprot):
23399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23401 
      return
23402 
    iprot.readStructBegin()
23403 
    while True:
23404 
      (fname, ftype, fid) = iprot.readFieldBegin()
23405 
      if ftype == TType.STOP:
23406 
        break
23407 
      if fid == 0:
23408 
        if ftype == TType.BOOL:
23409 
          self.success = iprot.readBool();
23410 
        else:
23411 
          iprot.skip(ftype)
23412 
      elif fid == 1:
23413 
        if ftype == TType.STRUCT:
23414 
          self.ex = TransactionServiceException()
23415 
          self.ex.read(iprot)
23416 
        else:
23417 
          iprot.skip(ftype)
23418 
      else:
23419 
        iprot.skip(ftype)
23420 
      iprot.readFieldEnd()
23421 
    iprot.readStructEnd()
23422 
 
23423 
  def write(self, oprot):
23424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23426 
      return
23427 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
23428 
    if self.success is not None:
23429 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23430 
      oprot.writeBool(self.success)
23431 
      oprot.writeFieldEnd()
23432 
    if self.ex is not None:
23433 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23434 
      self.ex.write(oprot)
23435 
      oprot.writeFieldEnd()
23436 
    oprot.writeFieldStop()
23437 
    oprot.writeStructEnd()
23438 
 
23439 
  def validate(self):
23440 
    return
23441 
 
23442 
 
23443 
  def __repr__(self):
23444 
    L = ['%s=%r' % (key, value)
23445 
      for key, value in self.__dict__.iteritems()]
23446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23447 
 
23448 
  def __eq__(self, other):
23449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23450 
 
23451 
  def __ne__(self, other):
23452 
    return not (self == other)
23453 
 
4386 anupam.sin 23454 
class getOrderForAwb_args:
23455 
  """
23456 
  Attributes:
23457 
   - awb
23458 
  """
23459 
 
23460 
  thrift_spec = (
23461 
    None, # 0
23462 
    (1, TType.STRING, 'awb', None, None, ), # 1
23463 
  )
23464 
 
23465 
  def __init__(self, awb=None,):
23466 
    self.awb = awb
23467 
 
23468 
  def read(self, iprot):
23469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23471 
      return
23472 
    iprot.readStructBegin()
23473 
    while True:
23474 
      (fname, ftype, fid) = iprot.readFieldBegin()
23475 
      if ftype == TType.STOP:
23476 
        break
23477 
      if fid == 1:
23478 
        if ftype == TType.STRING:
23479 
          self.awb = iprot.readString();
23480 
        else:
23481 
          iprot.skip(ftype)
23482 
      else:
23483 
        iprot.skip(ftype)
23484 
      iprot.readFieldEnd()
23485 
    iprot.readStructEnd()
23486 
 
23487 
  def write(self, oprot):
23488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23490 
      return
23491 
    oprot.writeStructBegin('getOrderForAwb_args')
23492 
    if self.awb is not None:
23493 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
23494 
      oprot.writeString(self.awb)
23495 
      oprot.writeFieldEnd()
23496 
    oprot.writeFieldStop()
23497 
    oprot.writeStructEnd()
23498 
 
23499 
  def validate(self):
23500 
    return
23501 
 
23502 
 
23503 
  def __repr__(self):
23504 
    L = ['%s=%r' % (key, value)
23505 
      for key, value in self.__dict__.iteritems()]
23506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23507 
 
23508 
  def __eq__(self, other):
23509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23510 
 
23511 
  def __ne__(self, other):
23512 
    return not (self == other)
23513 
 
23514 
class getOrderForAwb_result:
23515 
  """
23516 
  Attributes:
23517 
   - success
23518 
   - ex
23519 
  """
23520 
 
23521 
  thrift_spec = (
23522 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
23523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23524 
  )
23525 
 
23526 
  def __init__(self, success=None, ex=None,):
23527 
    self.success = success
23528 
    self.ex = ex
23529 
 
23530 
  def read(self, iprot):
23531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23533 
      return
23534 
    iprot.readStructBegin()
23535 
    while True:
23536 
      (fname, ftype, fid) = iprot.readFieldBegin()
23537 
      if ftype == TType.STOP:
23538 
        break
23539 
      if fid == 0:
23540 
        if ftype == TType.STRUCT:
23541 
          self.success = Order()
23542 
          self.success.read(iprot)
23543 
        else:
23544 
          iprot.skip(ftype)
23545 
      elif fid == 1:
23546 
        if ftype == TType.STRUCT:
23547 
          self.ex = TransactionServiceException()
23548 
          self.ex.read(iprot)
23549 
        else:
23550 
          iprot.skip(ftype)
23551 
      else:
23552 
        iprot.skip(ftype)
23553 
      iprot.readFieldEnd()
23554 
    iprot.readStructEnd()
23555 
 
23556 
  def write(self, oprot):
23557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23559 
      return
23560 
    oprot.writeStructBegin('getOrderForAwb_result')
23561 
    if self.success is not None:
23562 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23563 
      self.success.write(oprot)
23564 
      oprot.writeFieldEnd()
23565 
    if self.ex is not None:
23566 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23567 
      self.ex.write(oprot)
23568 
      oprot.writeFieldEnd()
23569 
    oprot.writeFieldStop()
23570 
    oprot.writeStructEnd()
23571 
 
23572 
  def validate(self):
23573 
    return
23574 
 
23575 
 
23576 
  def __repr__(self):
23577 
    L = ['%s=%r' % (key, value)
23578 
      for key, value in self.__dict__.iteritems()]
23579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23580 
 
23581 
  def __eq__(self, other):
23582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23583 
 
23584 
  def __ne__(self, other):
23585 
    return not (self == other)
4506 phani.kuma 23586 
 
23587 
class getOrdersForProviderForStatus_args:
23588 
  """
23589 
  Attributes:
23590 
   - logistics_provider_id
4910 phani.kuma 23591 
   - order_status_list
4506 phani.kuma 23592 
  """
23593 
 
23594 
  thrift_spec = (
23595 
    None, # 0
23596 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 23597 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 23598 
  )
23599 
 
4910 phani.kuma 23600 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 23601 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 23602 
    self.order_status_list = order_status_list
4506 phani.kuma 23603 
 
23604 
  def read(self, iprot):
23605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23607 
      return
23608 
    iprot.readStructBegin()
23609 
    while True:
23610 
      (fname, ftype, fid) = iprot.readFieldBegin()
23611 
      if ftype == TType.STOP:
23612 
        break
23613 
      if fid == 1:
23614 
        if ftype == TType.I64:
23615 
          self.logistics_provider_id = iprot.readI64();
23616 
        else:
23617 
          iprot.skip(ftype)
23618 
      elif fid == 2:
4910 phani.kuma 23619 
        if ftype == TType.LIST:
23620 
          self.order_status_list = []
6188 rajveer 23621 
          (_etype513, _size510) = iprot.readListBegin()
23622 
          for _i514 in xrange(_size510):
23623 
            _elem515 = iprot.readI32();
23624 
            self.order_status_list.append(_elem515)
4910 phani.kuma 23625 
          iprot.readListEnd()
4506 phani.kuma 23626 
        else:
23627 
          iprot.skip(ftype)
23628 
      else:
23629 
        iprot.skip(ftype)
23630 
      iprot.readFieldEnd()
23631 
    iprot.readStructEnd()
23632 
 
23633 
  def write(self, oprot):
23634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23636 
      return
23637 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
23638 
    if self.logistics_provider_id is not None:
23639 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
23640 
      oprot.writeI64(self.logistics_provider_id)
23641 
      oprot.writeFieldEnd()
4910 phani.kuma 23642 
    if self.order_status_list is not None:
23643 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
23644 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 23645 
      for iter516 in self.order_status_list:
23646 
        oprot.writeI32(iter516)
4910 phani.kuma 23647 
      oprot.writeListEnd()
4506 phani.kuma 23648 
      oprot.writeFieldEnd()
23649 
    oprot.writeFieldStop()
23650 
    oprot.writeStructEnd()
23651 
 
23652 
  def validate(self):
23653 
    return
23654 
 
23655 
 
23656 
  def __repr__(self):
23657 
    L = ['%s=%r' % (key, value)
23658 
      for key, value in self.__dict__.iteritems()]
23659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23660 
 
23661 
  def __eq__(self, other):
23662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23663 
 
23664 
  def __ne__(self, other):
23665 
    return not (self == other)
23666 
 
23667 
class getOrdersForProviderForStatus_result:
23668 
  """
23669 
  Attributes:
23670 
   - success
23671 
   - ex
23672 
  """
23673 
 
23674 
  thrift_spec = (
23675 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23676 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23677 
  )
23678 
 
23679 
  def __init__(self, success=None, ex=None,):
23680 
    self.success = success
23681 
    self.ex = ex
23682 
 
23683 
  def read(self, iprot):
23684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23686 
      return
23687 
    iprot.readStructBegin()
23688 
    while True:
23689 
      (fname, ftype, fid) = iprot.readFieldBegin()
23690 
      if ftype == TType.STOP:
23691 
        break
23692 
      if fid == 0:
23693 
        if ftype == TType.LIST:
23694 
          self.success = []
6188 rajveer 23695 
          (_etype520, _size517) = iprot.readListBegin()
23696 
          for _i521 in xrange(_size517):
23697 
            _elem522 = Order()
23698 
            _elem522.read(iprot)
23699 
            self.success.append(_elem522)
4506 phani.kuma 23700 
          iprot.readListEnd()
23701 
        else:
23702 
          iprot.skip(ftype)
23703 
      elif fid == 1:
23704 
        if ftype == TType.STRUCT:
23705 
          self.ex = TransactionServiceException()
23706 
          self.ex.read(iprot)
23707 
        else:
23708 
          iprot.skip(ftype)
23709 
      else:
23710 
        iprot.skip(ftype)
23711 
      iprot.readFieldEnd()
23712 
    iprot.readStructEnd()
23713 
 
23714 
  def write(self, oprot):
23715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23717 
      return
23718 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23719 
    if self.success is not None:
23720 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23721 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23722 
      for iter523 in self.success:
23723 
        iter523.write(oprot)
4506 phani.kuma 23724 
      oprot.writeListEnd()
23725 
      oprot.writeFieldEnd()
23726 
    if self.ex is not None:
23727 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23728 
      self.ex.write(oprot)
23729 
      oprot.writeFieldEnd()
23730 
    oprot.writeFieldStop()
23731 
    oprot.writeStructEnd()
23732 
 
23733 
  def validate(self):
23734 
    return
23735 
 
23736 
 
23737 
  def __repr__(self):
23738 
    L = ['%s=%r' % (key, value)
23739 
      for key, value in self.__dict__.iteritems()]
23740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23741 
 
23742 
  def __eq__(self, other):
23743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23744 
 
23745 
  def __ne__(self, other):
23746 
    return not (self == other)
4600 varun.gupt 23747 
 
23748 
class getBilledOrdersForVendor_args:
23749 
  """
23750 
  Attributes:
23751 
   - vendorId
23752 
   - billingDateFrom
23753 
   - billingDateTo
23754 
  """
23755 
 
23756 
  thrift_spec = (
23757 
    None, # 0
23758 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23759 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23760 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23761 
  )
23762 
 
23763 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23764 
    self.vendorId = vendorId
23765 
    self.billingDateFrom = billingDateFrom
23766 
    self.billingDateTo = billingDateTo
23767 
 
23768 
  def read(self, iprot):
23769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23771 
      return
23772 
    iprot.readStructBegin()
23773 
    while True:
23774 
      (fname, ftype, fid) = iprot.readFieldBegin()
23775 
      if ftype == TType.STOP:
23776 
        break
23777 
      if fid == 1:
23778 
        if ftype == TType.I64:
23779 
          self.vendorId = iprot.readI64();
23780 
        else:
23781 
          iprot.skip(ftype)
23782 
      elif fid == 2:
23783 
        if ftype == TType.I64:
23784 
          self.billingDateFrom = iprot.readI64();
23785 
        else:
23786 
          iprot.skip(ftype)
23787 
      elif fid == 3:
23788 
        if ftype == TType.I64:
23789 
          self.billingDateTo = iprot.readI64();
23790 
        else:
23791 
          iprot.skip(ftype)
23792 
      else:
23793 
        iprot.skip(ftype)
23794 
      iprot.readFieldEnd()
23795 
    iprot.readStructEnd()
23796 
 
23797 
  def write(self, oprot):
23798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23800 
      return
23801 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23802 
    if self.vendorId is not None:
23803 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23804 
      oprot.writeI64(self.vendorId)
23805 
      oprot.writeFieldEnd()
23806 
    if self.billingDateFrom is not None:
23807 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23808 
      oprot.writeI64(self.billingDateFrom)
23809 
      oprot.writeFieldEnd()
23810 
    if self.billingDateTo is not None:
23811 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23812 
      oprot.writeI64(self.billingDateTo)
23813 
      oprot.writeFieldEnd()
23814 
    oprot.writeFieldStop()
23815 
    oprot.writeStructEnd()
23816 
 
23817 
  def validate(self):
23818 
    return
23819 
 
23820 
 
23821 
  def __repr__(self):
23822 
    L = ['%s=%r' % (key, value)
23823 
      for key, value in self.__dict__.iteritems()]
23824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23825 
 
23826 
  def __eq__(self, other):
23827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23828 
 
23829 
  def __ne__(self, other):
23830 
    return not (self == other)
23831 
 
23832 
class getBilledOrdersForVendor_result:
23833 
  """
23834 
  Attributes:
23835 
   - success
23836 
   - ex
23837 
  """
23838 
 
23839 
  thrift_spec = (
23840 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23841 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23842 
  )
23843 
 
23844 
  def __init__(self, success=None, ex=None,):
23845 
    self.success = success
23846 
    self.ex = ex
23847 
 
23848 
  def read(self, iprot):
23849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23851 
      return
23852 
    iprot.readStructBegin()
23853 
    while True:
23854 
      (fname, ftype, fid) = iprot.readFieldBegin()
23855 
      if ftype == TType.STOP:
23856 
        break
23857 
      if fid == 0:
23858 
        if ftype == TType.LIST:
23859 
          self.success = []
6188 rajveer 23860 
          (_etype527, _size524) = iprot.readListBegin()
23861 
          for _i528 in xrange(_size524):
23862 
            _elem529 = Order()
23863 
            _elem529.read(iprot)
23864 
            self.success.append(_elem529)
4600 varun.gupt 23865 
          iprot.readListEnd()
23866 
        else:
23867 
          iprot.skip(ftype)
23868 
      elif fid == 1:
23869 
        if ftype == TType.STRUCT:
23870 
          self.ex = TransactionServiceException()
23871 
          self.ex.read(iprot)
23872 
        else:
23873 
          iprot.skip(ftype)
23874 
      else:
23875 
        iprot.skip(ftype)
23876 
      iprot.readFieldEnd()
23877 
    iprot.readStructEnd()
23878 
 
23879 
  def write(self, oprot):
23880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23882 
      return
23883 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23884 
    if self.success is not None:
23885 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23886 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23887 
      for iter530 in self.success:
23888 
        iter530.write(oprot)
4600 varun.gupt 23889 
      oprot.writeListEnd()
23890 
      oprot.writeFieldEnd()
23891 
    if self.ex is not None:
23892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23893 
      self.ex.write(oprot)
23894 
      oprot.writeFieldEnd()
23895 
    oprot.writeFieldStop()
23896 
    oprot.writeStructEnd()
23897 
 
23898 
  def validate(self):
23899 
    return
23900 
 
23901 
 
23902 
  def __repr__(self):
23903 
    L = ['%s=%r' % (key, value)
23904 
      for key, value in self.__dict__.iteritems()]
23905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23906 
 
23907 
  def __eq__(self, other):
23908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23909 
 
23910 
  def __ne__(self, other):
23911 
    return not (self == other)
23912 
 
4607 rajveer 23913 
class getSlippedSippingDateOrders_args:
23914 
 
23915 
  thrift_spec = (
23916 
  )
23917 
 
23918 
  def read(self, iprot):
23919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23921 
      return
23922 
    iprot.readStructBegin()
23923 
    while True:
23924 
      (fname, ftype, fid) = iprot.readFieldBegin()
23925 
      if ftype == TType.STOP:
23926 
        break
23927 
      else:
23928 
        iprot.skip(ftype)
23929 
      iprot.readFieldEnd()
23930 
    iprot.readStructEnd()
23931 
 
23932 
  def write(self, oprot):
23933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23935 
      return
23936 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23937 
    oprot.writeFieldStop()
23938 
    oprot.writeStructEnd()
23939 
 
23940 
  def validate(self):
23941 
    return
23942 
 
23943 
 
23944 
  def __repr__(self):
23945 
    L = ['%s=%r' % (key, value)
23946 
      for key, value in self.__dict__.iteritems()]
23947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23948 
 
23949 
  def __eq__(self, other):
23950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23951 
 
23952 
  def __ne__(self, other):
23953 
    return not (self == other)
23954 
 
23955 
class getSlippedSippingDateOrders_result:
23956 
  """
23957 
  Attributes:
23958 
   - success
23959 
   - ex
23960 
  """
23961 
 
23962 
  thrift_spec = (
23963 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23964 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23965 
  )
23966 
 
23967 
  def __init__(self, success=None, ex=None,):
23968 
    self.success = success
23969 
    self.ex = ex
23970 
 
23971 
  def read(self, iprot):
23972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23974 
      return
23975 
    iprot.readStructBegin()
23976 
    while True:
23977 
      (fname, ftype, fid) = iprot.readFieldBegin()
23978 
      if ftype == TType.STOP:
23979 
        break
23980 
      if fid == 0:
23981 
        if ftype == TType.LIST:
23982 
          self.success = []
6188 rajveer 23983 
          (_etype534, _size531) = iprot.readListBegin()
23984 
          for _i535 in xrange(_size531):
23985 
            _elem536 = Order()
23986 
            _elem536.read(iprot)
23987 
            self.success.append(_elem536)
4607 rajveer 23988 
          iprot.readListEnd()
23989 
        else:
23990 
          iprot.skip(ftype)
23991 
      elif fid == 1:
23992 
        if ftype == TType.STRUCT:
23993 
          self.ex = TransactionServiceException()
23994 
          self.ex.read(iprot)
23995 
        else:
23996 
          iprot.skip(ftype)
23997 
      else:
23998 
        iprot.skip(ftype)
23999 
      iprot.readFieldEnd()
24000 
    iprot.readStructEnd()
24001 
 
24002 
  def write(self, oprot):
24003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24005 
      return
24006 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
24007 
    if self.success is not None:
24008 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24009 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24010 
      for iter537 in self.success:
24011 
        iter537.write(oprot)
4607 rajveer 24012 
      oprot.writeListEnd()
24013 
      oprot.writeFieldEnd()
24014 
    if self.ex is not None:
24015 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24016 
      self.ex.write(oprot)
24017 
      oprot.writeFieldEnd()
24018 
    oprot.writeFieldStop()
24019 
    oprot.writeStructEnd()
24020 
 
24021 
  def validate(self):
24022 
    return
24023 
 
24024 
 
24025 
  def __repr__(self):
24026 
    L = ['%s=%r' % (key, value)
24027 
      for key, value in self.__dict__.iteritems()]
24028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24029 
 
24030 
  def __eq__(self, other):
24031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24032 
 
24033 
  def __ne__(self, other):
24034 
    return not (self == other)
24035 
 
4709 rajveer 24036 
class getCancelledOrders_args:
24037 
  """
24038 
  Attributes:
24039 
   - cancelDateFrom
24040 
   - cancelDateTo
24041 
  """
24042 
 
24043 
  thrift_spec = (
24044 
    None, # 0
24045 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
24046 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
24047 
  )
24048 
 
24049 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
24050 
    self.cancelDateFrom = cancelDateFrom
24051 
    self.cancelDateTo = cancelDateTo
24052 
 
24053 
  def read(self, iprot):
24054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24056 
      return
24057 
    iprot.readStructBegin()
24058 
    while True:
24059 
      (fname, ftype, fid) = iprot.readFieldBegin()
24060 
      if ftype == TType.STOP:
24061 
        break
24062 
      if fid == 1:
24063 
        if ftype == TType.I64:
24064 
          self.cancelDateFrom = iprot.readI64();
24065 
        else:
24066 
          iprot.skip(ftype)
24067 
      elif fid == 2:
24068 
        if ftype == TType.I64:
24069 
          self.cancelDateTo = iprot.readI64();
24070 
        else:
24071 
          iprot.skip(ftype)
24072 
      else:
24073 
        iprot.skip(ftype)
24074 
      iprot.readFieldEnd()
24075 
    iprot.readStructEnd()
24076 
 
24077 
  def write(self, oprot):
24078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24080 
      return
24081 
    oprot.writeStructBegin('getCancelledOrders_args')
24082 
    if self.cancelDateFrom is not None:
24083 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
24084 
      oprot.writeI64(self.cancelDateFrom)
24085 
      oprot.writeFieldEnd()
24086 
    if self.cancelDateTo is not None:
24087 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
24088 
      oprot.writeI64(self.cancelDateTo)
24089 
      oprot.writeFieldEnd()
24090 
    oprot.writeFieldStop()
24091 
    oprot.writeStructEnd()
24092 
 
24093 
  def validate(self):
24094 
    return
24095 
 
24096 
 
24097 
  def __repr__(self):
24098 
    L = ['%s=%r' % (key, value)
24099 
      for key, value in self.__dict__.iteritems()]
24100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24101 
 
24102 
  def __eq__(self, other):
24103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24104 
 
24105 
  def __ne__(self, other):
24106 
    return not (self == other)
24107 
 
24108 
class getCancelledOrders_result:
24109 
  """
24110 
  Attributes:
24111 
   - success
24112 
   - ex
24113 
  """
24114 
 
24115 
  thrift_spec = (
24116 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24118 
  )
24119 
 
24120 
  def __init__(self, success=None, ex=None,):
24121 
    self.success = success
24122 
    self.ex = ex
24123 
 
24124 
  def read(self, iprot):
24125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24127 
      return
24128 
    iprot.readStructBegin()
24129 
    while True:
24130 
      (fname, ftype, fid) = iprot.readFieldBegin()
24131 
      if ftype == TType.STOP:
24132 
        break
24133 
      if fid == 0:
24134 
        if ftype == TType.LIST:
24135 
          self.success = []
6188 rajveer 24136 
          (_etype541, _size538) = iprot.readListBegin()
24137 
          for _i542 in xrange(_size538):
24138 
            _elem543 = Order()
24139 
            _elem543.read(iprot)
24140 
            self.success.append(_elem543)
4709 rajveer 24141 
          iprot.readListEnd()
24142 
        else:
24143 
          iprot.skip(ftype)
24144 
      elif fid == 1:
24145 
        if ftype == TType.STRUCT:
24146 
          self.ex = TransactionServiceException()
24147 
          self.ex.read(iprot)
24148 
        else:
24149 
          iprot.skip(ftype)
24150 
      else:
24151 
        iprot.skip(ftype)
24152 
      iprot.readFieldEnd()
24153 
    iprot.readStructEnd()
24154 
 
24155 
  def write(self, oprot):
24156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24158 
      return
24159 
    oprot.writeStructBegin('getCancelledOrders_result')
24160 
    if self.success is not None:
24161 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24162 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24163 
      for iter544 in self.success:
24164 
        iter544.write(oprot)
4709 rajveer 24165 
      oprot.writeListEnd()
24166 
      oprot.writeFieldEnd()
24167 
    if self.ex is not None:
24168 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24169 
      self.ex.write(oprot)
24170 
      oprot.writeFieldEnd()
24171 
    oprot.writeFieldStop()
24172 
    oprot.writeStructEnd()
24173 
 
24174 
  def validate(self):
24175 
    return
24176 
 
24177 
 
24178 
  def __repr__(self):
24179 
    L = ['%s=%r' % (key, value)
24180 
      for key, value in self.__dict__.iteritems()]
24181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24182 
 
24183 
  def __eq__(self, other):
24184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24185 
 
24186 
  def __ne__(self, other):
24187 
    return not (self == other)
24188 
 
4600 varun.gupt 24189 
class saveBluedartSettlements_args:
24190 
  """
24191 
  Attributes:
24192 
   - mapAWBAndAmount
24193 
  """
24194 
 
24195 
  thrift_spec = (
24196 
    None, # 0
24197 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
24198 
  )
24199 
 
24200 
  def __init__(self, mapAWBAndAmount=None,):
24201 
    self.mapAWBAndAmount = mapAWBAndAmount
24202 
 
24203 
  def read(self, iprot):
24204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24206 
      return
24207 
    iprot.readStructBegin()
24208 
    while True:
24209 
      (fname, ftype, fid) = iprot.readFieldBegin()
24210 
      if ftype == TType.STOP:
24211 
        break
24212 
      if fid == 1:
24213 
        if ftype == TType.MAP:
24214 
          self.mapAWBAndAmount = {}
6188 rajveer 24215 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
24216 
          for _i549 in xrange(_size545):
24217 
            _key550 = iprot.readI64();
24218 
            _val551 = iprot.readDouble();
24219 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 24220 
          iprot.readMapEnd()
24221 
        else:
24222 
          iprot.skip(ftype)
24223 
      else:
24224 
        iprot.skip(ftype)
24225 
      iprot.readFieldEnd()
24226 
    iprot.readStructEnd()
24227 
 
24228 
  def write(self, oprot):
24229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24231 
      return
24232 
    oprot.writeStructBegin('saveBluedartSettlements_args')
24233 
    if self.mapAWBAndAmount is not None:
24234 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
24235 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 24236 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
24237 
        oprot.writeI64(kiter552)
24238 
        oprot.writeDouble(viter553)
4600 varun.gupt 24239 
      oprot.writeMapEnd()
24240 
      oprot.writeFieldEnd()
24241 
    oprot.writeFieldStop()
24242 
    oprot.writeStructEnd()
24243 
 
24244 
  def validate(self):
24245 
    return
24246 
 
24247 
 
24248 
  def __repr__(self):
24249 
    L = ['%s=%r' % (key, value)
24250 
      for key, value in self.__dict__.iteritems()]
24251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24252 
 
24253 
  def __eq__(self, other):
24254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24255 
 
24256 
  def __ne__(self, other):
24257 
    return not (self == other)
24258 
 
24259 
class saveBluedartSettlements_result:
24260 
  """
24261 
  Attributes:
24262 
   - ex
24263 
  """
24264 
 
24265 
  thrift_spec = (
24266 
    None, # 0
24267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24268 
  )
24269 
 
24270 
  def __init__(self, ex=None,):
24271 
    self.ex = ex
24272 
 
24273 
  def read(self, iprot):
24274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24276 
      return
24277 
    iprot.readStructBegin()
24278 
    while True:
24279 
      (fname, ftype, fid) = iprot.readFieldBegin()
24280 
      if ftype == TType.STOP:
24281 
        break
24282 
      if fid == 1:
24283 
        if ftype == TType.STRUCT:
24284 
          self.ex = TransactionServiceException()
24285 
          self.ex.read(iprot)
24286 
        else:
24287 
          iprot.skip(ftype)
24288 
      else:
24289 
        iprot.skip(ftype)
24290 
      iprot.readFieldEnd()
24291 
    iprot.readStructEnd()
24292 
 
24293 
  def write(self, oprot):
24294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24296 
      return
24297 
    oprot.writeStructBegin('saveBluedartSettlements_result')
24298 
    if self.ex is not None:
24299 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24300 
      self.ex.write(oprot)
24301 
      oprot.writeFieldEnd()
24302 
    oprot.writeFieldStop()
24303 
    oprot.writeStructEnd()
24304 
 
24305 
  def validate(self):
24306 
    return
24307 
 
24308 
 
24309 
  def __repr__(self):
24310 
    L = ['%s=%r' % (key, value)
24311 
      for key, value in self.__dict__.iteritems()]
24312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24313 
 
24314 
  def __eq__(self, other):
24315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24316 
 
24317 
  def __ne__(self, other):
24318 
    return not (self == other)
24319 
 
24320 
class savePaymentSettlements_args:
24321 
  """
24322 
  Attributes:
24323 
   - settlementDate
24324 
   - paymentGatewayId
4905 varun.gupt 24325 
   - referenceId
4600 varun.gupt 24326 
   - serviceTax
24327 
   - otherCharges
24328 
   - netCollection
24329 
  """
24330 
 
24331 
  thrift_spec = (
24332 
    None, # 0
24333 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
24334 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 24335 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 24336 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
24337 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
24338 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
24339 
  )
24340 
 
4905 varun.gupt 24341 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 24342 
    self.settlementDate = settlementDate
24343 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 24344 
    self.referenceId = referenceId
4600 varun.gupt 24345 
    self.serviceTax = serviceTax
24346 
    self.otherCharges = otherCharges
24347 
    self.netCollection = netCollection
24348 
 
24349 
  def read(self, iprot):
24350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24352 
      return
24353 
    iprot.readStructBegin()
24354 
    while True:
24355 
      (fname, ftype, fid) = iprot.readFieldBegin()
24356 
      if ftype == TType.STOP:
24357 
        break
24358 
      if fid == 1:
24359 
        if ftype == TType.I64:
24360 
          self.settlementDate = iprot.readI64();
24361 
        else:
24362 
          iprot.skip(ftype)
24363 
      elif fid == 2:
24364 
        if ftype == TType.I64:
24365 
          self.paymentGatewayId = iprot.readI64();
24366 
        else:
24367 
          iprot.skip(ftype)
24368 
      elif fid == 3:
24369 
        if ftype == TType.I64:
4905 varun.gupt 24370 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24371 
        else:
24372 
          iprot.skip(ftype)
24373 
      elif fid == 4:
24374 
        if ftype == TType.DOUBLE:
24375 
          self.serviceTax = iprot.readDouble();
24376 
        else:
24377 
          iprot.skip(ftype)
24378 
      elif fid == 5:
24379 
        if ftype == TType.DOUBLE:
24380 
          self.otherCharges = iprot.readDouble();
24381 
        else:
24382 
          iprot.skip(ftype)
24383 
      elif fid == 6:
24384 
        if ftype == TType.DOUBLE:
24385 
          self.netCollection = iprot.readDouble();
24386 
        else:
24387 
          iprot.skip(ftype)
24388 
      else:
24389 
        iprot.skip(ftype)
24390 
      iprot.readFieldEnd()
24391 
    iprot.readStructEnd()
24392 
 
24393 
  def write(self, oprot):
24394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24396 
      return
24397 
    oprot.writeStructBegin('savePaymentSettlements_args')
24398 
    if self.settlementDate is not None:
24399 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
24400 
      oprot.writeI64(self.settlementDate)
24401 
      oprot.writeFieldEnd()
24402 
    if self.paymentGatewayId is not None:
24403 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
24404 
      oprot.writeI64(self.paymentGatewayId)
24405 
      oprot.writeFieldEnd()
4905 varun.gupt 24406 
    if self.referenceId is not None:
24407 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
24408 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24409 
      oprot.writeFieldEnd()
24410 
    if self.serviceTax is not None:
24411 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
24412 
      oprot.writeDouble(self.serviceTax)
24413 
      oprot.writeFieldEnd()
24414 
    if self.otherCharges is not None:
24415 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
24416 
      oprot.writeDouble(self.otherCharges)
24417 
      oprot.writeFieldEnd()
24418 
    if self.netCollection is not None:
24419 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
24420 
      oprot.writeDouble(self.netCollection)
24421 
      oprot.writeFieldEnd()
24422 
    oprot.writeFieldStop()
24423 
    oprot.writeStructEnd()
24424 
 
24425 
  def validate(self):
24426 
    return
24427 
 
24428 
 
24429 
  def __repr__(self):
24430 
    L = ['%s=%r' % (key, value)
24431 
      for key, value in self.__dict__.iteritems()]
24432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24433 
 
24434 
  def __eq__(self, other):
24435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24436 
 
24437 
  def __ne__(self, other):
24438 
    return not (self == other)
24439 
 
24440 
class savePaymentSettlements_result:
24441 
  """
24442 
  Attributes:
24443 
   - ex
24444 
  """
24445 
 
24446 
  thrift_spec = (
24447 
    None, # 0
24448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24449 
  )
24450 
 
24451 
  def __init__(self, ex=None,):
24452 
    self.ex = ex
24453 
 
24454 
  def read(self, iprot):
24455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24457 
      return
24458 
    iprot.readStructBegin()
24459 
    while True:
24460 
      (fname, ftype, fid) = iprot.readFieldBegin()
24461 
      if ftype == TType.STOP:
24462 
        break
24463 
      if fid == 1:
24464 
        if ftype == TType.STRUCT:
24465 
          self.ex = TransactionServiceException()
24466 
          self.ex.read(iprot)
24467 
        else:
24468 
          iprot.skip(ftype)
24469 
      else:
24470 
        iprot.skip(ftype)
24471 
      iprot.readFieldEnd()
24472 
    iprot.readStructEnd()
24473 
 
24474 
  def write(self, oprot):
24475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24477 
      return
24478 
    oprot.writeStructBegin('savePaymentSettlements_result')
24479 
    if self.ex is not None:
24480 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24481 
      self.ex.write(oprot)
24482 
      oprot.writeFieldEnd()
24483 
    oprot.writeFieldStop()
24484 
    oprot.writeStructEnd()
24485 
 
24486 
  def validate(self):
24487 
    return
24488 
 
24489 
 
24490 
  def __repr__(self):
24491 
    L = ['%s=%r' % (key, value)
24492 
      for key, value in self.__dict__.iteritems()]
24493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24494 
 
24495 
  def __eq__(self, other):
24496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24497 
 
24498 
  def __ne__(self, other):
24499 
    return not (self == other)
24500 
 
24501 
class saveEBSSettlementSummary_args:
24502 
  """
24503 
  Attributes:
24504 
   - settlementId
24505 
   - settlementDate
24506 
   - transactionDateFrom
24507 
   - transactionDateTo
24508 
   - amount
24509 
  """
24510 
 
24511 
  thrift_spec = (
24512 
    None, # 0
24513 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24514 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
24515 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
24516 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
24517 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
24518 
  )
24519 
 
24520 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
24521 
    self.settlementId = settlementId
24522 
    self.settlementDate = settlementDate
24523 
    self.transactionDateFrom = transactionDateFrom
24524 
    self.transactionDateTo = transactionDateTo
24525 
    self.amount = amount
24526 
 
24527 
  def read(self, iprot):
24528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24530 
      return
24531 
    iprot.readStructBegin()
24532 
    while True:
24533 
      (fname, ftype, fid) = iprot.readFieldBegin()
24534 
      if ftype == TType.STOP:
24535 
        break
24536 
      if fid == 1:
24537 
        if ftype == TType.I64:
24538 
          self.settlementId = iprot.readI64();
24539 
        else:
24540 
          iprot.skip(ftype)
24541 
      elif fid == 2:
24542 
        if ftype == TType.I64:
24543 
          self.settlementDate = iprot.readI64();
24544 
        else:
24545 
          iprot.skip(ftype)
24546 
      elif fid == 3:
24547 
        if ftype == TType.I64:
24548 
          self.transactionDateFrom = iprot.readI64();
24549 
        else:
24550 
          iprot.skip(ftype)
24551 
      elif fid == 4:
24552 
        if ftype == TType.I64:
24553 
          self.transactionDateTo = iprot.readI64();
24554 
        else:
24555 
          iprot.skip(ftype)
24556 
      elif fid == 5:
24557 
        if ftype == TType.DOUBLE:
24558 
          self.amount = iprot.readDouble();
24559 
        else:
24560 
          iprot.skip(ftype)
24561 
      else:
24562 
        iprot.skip(ftype)
24563 
      iprot.readFieldEnd()
24564 
    iprot.readStructEnd()
24565 
 
24566 
  def write(self, oprot):
24567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24569 
      return
24570 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
24571 
    if self.settlementId is not None:
24572 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24573 
      oprot.writeI64(self.settlementId)
24574 
      oprot.writeFieldEnd()
24575 
    if self.settlementDate is not None:
24576 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
24577 
      oprot.writeI64(self.settlementDate)
24578 
      oprot.writeFieldEnd()
24579 
    if self.transactionDateFrom is not None:
24580 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
24581 
      oprot.writeI64(self.transactionDateFrom)
24582 
      oprot.writeFieldEnd()
24583 
    if self.transactionDateTo is not None:
24584 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
24585 
      oprot.writeI64(self.transactionDateTo)
24586 
      oprot.writeFieldEnd()
24587 
    if self.amount is not None:
24588 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
24589 
      oprot.writeDouble(self.amount)
24590 
      oprot.writeFieldEnd()
24591 
    oprot.writeFieldStop()
24592 
    oprot.writeStructEnd()
24593 
 
24594 
  def validate(self):
24595 
    return
24596 
 
24597 
 
24598 
  def __repr__(self):
24599 
    L = ['%s=%r' % (key, value)
24600 
      for key, value in self.__dict__.iteritems()]
24601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24602 
 
24603 
  def __eq__(self, other):
24604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24605 
 
24606 
  def __ne__(self, other):
24607 
    return not (self == other)
24608 
 
24609 
class saveEBSSettlementSummary_result:
24610 
  """
24611 
  Attributes:
24612 
   - ex
24613 
  """
24614 
 
24615 
  thrift_spec = (
24616 
    None, # 0
24617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24618 
  )
24619 
 
24620 
  def __init__(self, ex=None,):
24621 
    self.ex = ex
24622 
 
24623 
  def read(self, iprot):
24624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24626 
      return
24627 
    iprot.readStructBegin()
24628 
    while True:
24629 
      (fname, ftype, fid) = iprot.readFieldBegin()
24630 
      if ftype == TType.STOP:
24631 
        break
24632 
      if fid == 1:
24633 
        if ftype == TType.STRUCT:
24634 
          self.ex = TransactionServiceException()
24635 
          self.ex.read(iprot)
24636 
        else:
24637 
          iprot.skip(ftype)
24638 
      else:
24639 
        iprot.skip(ftype)
24640 
      iprot.readFieldEnd()
24641 
    iprot.readStructEnd()
24642 
 
24643 
  def write(self, oprot):
24644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24646 
      return
24647 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
24648 
    if self.ex is not None:
24649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24650 
      self.ex.write(oprot)
24651 
      oprot.writeFieldEnd()
24652 
    oprot.writeFieldStop()
24653 
    oprot.writeStructEnd()
24654 
 
24655 
  def validate(self):
24656 
    return
24657 
 
24658 
 
24659 
  def __repr__(self):
24660 
    L = ['%s=%r' % (key, value)
24661 
      for key, value in self.__dict__.iteritems()]
24662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24663 
 
24664 
  def __eq__(self, other):
24665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24666 
 
24667 
  def __ne__(self, other):
24668 
    return not (self == other)
24669 
 
5386 phani.kuma 24670 
class getSettlementForPrepaid_args:
4600 varun.gupt 24671 
  """
24672 
  Attributes:
5189 varun.gupt 24673 
   - referenceId
24674 
   - isRefund
4600 varun.gupt 24675 
  """
24676 
 
24677 
  thrift_spec = (
24678 
    None, # 0
5189 varun.gupt 24679 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24680 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24681 
  )
24682 
 
5386 phani.kuma 24683 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24684 
    self.referenceId = referenceId
24685 
    self.isRefund = isRefund
4600 varun.gupt 24686 
 
24687 
  def read(self, iprot):
24688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24690 
      return
24691 
    iprot.readStructBegin()
24692 
    while True:
24693 
      (fname, ftype, fid) = iprot.readFieldBegin()
24694 
      if ftype == TType.STOP:
24695 
        break
24696 
      if fid == 1:
24697 
        if ftype == TType.I64:
5189 varun.gupt 24698 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24699 
        else:
24700 
          iprot.skip(ftype)
5189 varun.gupt 24701 
      elif fid == 2:
24702 
        if ftype == TType.BOOL:
24703 
          self.isRefund = iprot.readBool();
24704 
        else:
24705 
          iprot.skip(ftype)
4600 varun.gupt 24706 
      else:
24707 
        iprot.skip(ftype)
24708 
      iprot.readFieldEnd()
24709 
    iprot.readStructEnd()
24710 
 
24711 
  def write(self, oprot):
24712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24714 
      return
5386 phani.kuma 24715 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24716 
    if self.referenceId is not None:
24717 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24718 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24719 
      oprot.writeFieldEnd()
5386 phani.kuma 24720 
    if self.isRefund is not None:
24721 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24722 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24723 
      oprot.writeFieldEnd()
5386 phani.kuma 24724 
    oprot.writeFieldStop()
24725 
    oprot.writeStructEnd()
24726 
 
24727 
  def validate(self):
24728 
    return
24729 
 
24730 
 
24731 
  def __repr__(self):
24732 
    L = ['%s=%r' % (key, value)
24733 
      for key, value in self.__dict__.iteritems()]
24734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24735 
 
24736 
  def __eq__(self, other):
24737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24738 
 
24739 
  def __ne__(self, other):
24740 
    return not (self == other)
24741 
 
24742 
class getSettlementForPrepaid_result:
24743 
  """
24744 
  Attributes:
24745 
   - success
24746 
   - ex
24747 
  """
24748 
 
24749 
  thrift_spec = (
24750 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24751 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24752 
  )
24753 
 
24754 
  def __init__(self, success=None, ex=None,):
24755 
    self.success = success
24756 
    self.ex = ex
24757 
 
24758 
  def read(self, iprot):
24759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24761 
      return
24762 
    iprot.readStructBegin()
24763 
    while True:
24764 
      (fname, ftype, fid) = iprot.readFieldBegin()
24765 
      if ftype == TType.STOP:
24766 
        break
24767 
      if fid == 0:
24768 
        if ftype == TType.STRUCT:
24769 
          self.success = PaymentSettlement()
24770 
          self.success.read(iprot)
24771 
        else:
24772 
          iprot.skip(ftype)
24773 
      elif fid == 1:
24774 
        if ftype == TType.STRUCT:
24775 
          self.ex = TransactionServiceException()
24776 
          self.ex.read(iprot)
24777 
        else:
24778 
          iprot.skip(ftype)
24779 
      else:
24780 
        iprot.skip(ftype)
24781 
      iprot.readFieldEnd()
24782 
    iprot.readStructEnd()
24783 
 
24784 
  def write(self, oprot):
24785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24787 
      return
24788 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24789 
    if self.success is not None:
24790 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24791 
      self.success.write(oprot)
24792 
      oprot.writeFieldEnd()
24793 
    if self.ex is not None:
24794 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24795 
      self.ex.write(oprot)
24796 
      oprot.writeFieldEnd()
24797 
    oprot.writeFieldStop()
24798 
    oprot.writeStructEnd()
24799 
 
24800 
  def validate(self):
24801 
    return
24802 
 
24803 
 
24804 
  def __repr__(self):
24805 
    L = ['%s=%r' % (key, value)
24806 
      for key, value in self.__dict__.iteritems()]
24807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24808 
 
24809 
  def __eq__(self, other):
24810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24811 
 
24812 
  def __ne__(self, other):
24813 
    return not (self == other)
24814 
 
24815 
class getSettlementForCod_args:
24816 
  """
24817 
  Attributes:
24818 
   - orderId
24819 
   - isRefund
24820 
  """
24821 
 
24822 
  thrift_spec = (
24823 
    None, # 0
24824 
    (1, TType.I64, 'orderId', None, None, ), # 1
24825 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24826 
  )
24827 
 
24828 
  def __init__(self, orderId=None, isRefund=None,):
24829 
    self.orderId = orderId
24830 
    self.isRefund = isRefund
24831 
 
24832 
  def read(self, iprot):
24833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24835 
      return
24836 
    iprot.readStructBegin()
24837 
    while True:
24838 
      (fname, ftype, fid) = iprot.readFieldBegin()
24839 
      if ftype == TType.STOP:
24840 
        break
24841 
      if fid == 1:
24842 
        if ftype == TType.I64:
24843 
          self.orderId = iprot.readI64();
24844 
        else:
24845 
          iprot.skip(ftype)
24846 
      elif fid == 2:
24847 
        if ftype == TType.BOOL:
24848 
          self.isRefund = iprot.readBool();
24849 
        else:
24850 
          iprot.skip(ftype)
24851 
      else:
24852 
        iprot.skip(ftype)
24853 
      iprot.readFieldEnd()
24854 
    iprot.readStructEnd()
24855 
 
24856 
  def write(self, oprot):
24857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24859 
      return
24860 
    oprot.writeStructBegin('getSettlementForCod_args')
24861 
    if self.orderId is not None:
24862 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24863 
      oprot.writeI64(self.orderId)
24864 
      oprot.writeFieldEnd()
5189 varun.gupt 24865 
    if self.isRefund is not None:
5386 phani.kuma 24866 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24867 
      oprot.writeBool(self.isRefund)
24868 
      oprot.writeFieldEnd()
4600 varun.gupt 24869 
    oprot.writeFieldStop()
24870 
    oprot.writeStructEnd()
24871 
 
24872 
  def validate(self):
24873 
    return
24874 
 
24875 
 
24876 
  def __repr__(self):
24877 
    L = ['%s=%r' % (key, value)
24878 
      for key, value in self.__dict__.iteritems()]
24879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24880 
 
24881 
  def __eq__(self, other):
24882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24883 
 
24884 
  def __ne__(self, other):
24885 
    return not (self == other)
24886 
 
5386 phani.kuma 24887 
class getSettlementForCod_result:
4600 varun.gupt 24888 
  """
24889 
  Attributes:
24890 
   - success
24891 
   - ex
24892 
  """
24893 
 
24894 
  thrift_spec = (
24895 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24896 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24897 
  )
24898 
 
24899 
  def __init__(self, success=None, ex=None,):
24900 
    self.success = success
24901 
    self.ex = ex
24902 
 
24903 
  def read(self, iprot):
24904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24906 
      return
24907 
    iprot.readStructBegin()
24908 
    while True:
24909 
      (fname, ftype, fid) = iprot.readFieldBegin()
24910 
      if ftype == TType.STOP:
24911 
        break
24912 
      if fid == 0:
24913 
        if ftype == TType.STRUCT:
24914 
          self.success = PaymentSettlement()
24915 
          self.success.read(iprot)
24916 
        else:
24917 
          iprot.skip(ftype)
24918 
      elif fid == 1:
24919 
        if ftype == TType.STRUCT:
24920 
          self.ex = TransactionServiceException()
24921 
          self.ex.read(iprot)
24922 
        else:
24923 
          iprot.skip(ftype)
24924 
      else:
24925 
        iprot.skip(ftype)
24926 
      iprot.readFieldEnd()
24927 
    iprot.readStructEnd()
24928 
 
24929 
  def write(self, oprot):
24930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24932 
      return
5386 phani.kuma 24933 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24934 
    if self.success is not None:
24935 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24936 
      self.success.write(oprot)
24937 
      oprot.writeFieldEnd()
24938 
    if self.ex is not None:
24939 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24940 
      self.ex.write(oprot)
24941 
      oprot.writeFieldEnd()
24942 
    oprot.writeFieldStop()
24943 
    oprot.writeStructEnd()
24944 
 
24945 
  def validate(self):
24946 
    return
24947 
 
24948 
 
24949 
  def __repr__(self):
24950 
    L = ['%s=%r' % (key, value)
24951 
      for key, value in self.__dict__.iteritems()]
24952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24953 
 
24954 
  def __eq__(self, other):
24955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24956 
 
24957 
  def __ne__(self, other):
24958 
    return not (self == other)
24959 
 
24960 
class getEBSSettlementSummaries_args:
24961 
 
24962 
  thrift_spec = (
24963 
  )
24964 
 
24965 
  def read(self, iprot):
24966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24968 
      return
24969 
    iprot.readStructBegin()
24970 
    while True:
24971 
      (fname, ftype, fid) = iprot.readFieldBegin()
24972 
      if ftype == TType.STOP:
24973 
        break
24974 
      else:
24975 
        iprot.skip(ftype)
24976 
      iprot.readFieldEnd()
24977 
    iprot.readStructEnd()
24978 
 
24979 
  def write(self, oprot):
24980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24982 
      return
24983 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24984 
    oprot.writeFieldStop()
24985 
    oprot.writeStructEnd()
24986 
 
24987 
  def validate(self):
24988 
    return
24989 
 
24990 
 
24991 
  def __repr__(self):
24992 
    L = ['%s=%r' % (key, value)
24993 
      for key, value in self.__dict__.iteritems()]
24994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24995 
 
24996 
  def __eq__(self, other):
24997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24998 
 
24999 
  def __ne__(self, other):
25000 
    return not (self == other)
25001 
 
25002 
class getEBSSettlementSummaries_result:
25003 
  """
25004 
  Attributes:
25005 
   - success
25006 
   - ex
25007 
  """
25008 
 
25009 
  thrift_spec = (
25010 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
25011 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25012 
  )
25013 
 
25014 
  def __init__(self, success=None, ex=None,):
25015 
    self.success = success
25016 
    self.ex = ex
25017 
 
25018 
  def read(self, iprot):
25019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25021 
      return
25022 
    iprot.readStructBegin()
25023 
    while True:
25024 
      (fname, ftype, fid) = iprot.readFieldBegin()
25025 
      if ftype == TType.STOP:
25026 
        break
25027 
      if fid == 0:
25028 
        if ftype == TType.MAP:
25029 
          self.success = {}
6188 rajveer 25030 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
25031 
          for _i558 in xrange(_size554):
25032 
            _key559 = iprot.readI64();
25033 
            _val560 = iprot.readString();
25034 
            self.success[_key559] = _val560
4600 varun.gupt 25035 
          iprot.readMapEnd()
25036 
        else:
25037 
          iprot.skip(ftype)
25038 
      elif fid == 1:
25039 
        if ftype == TType.STRUCT:
25040 
          self.ex = TransactionServiceException()
25041 
          self.ex.read(iprot)
25042 
        else:
25043 
          iprot.skip(ftype)
25044 
      else:
25045 
        iprot.skip(ftype)
25046 
      iprot.readFieldEnd()
25047 
    iprot.readStructEnd()
25048 
 
25049 
  def write(self, oprot):
25050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25052 
      return
25053 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
25054 
    if self.success is not None:
25055 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25056 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 25057 
      for kiter561,viter562 in self.success.items():
25058 
        oprot.writeI64(kiter561)
25059 
        oprot.writeString(viter562)
4600 varun.gupt 25060 
      oprot.writeMapEnd()
25061 
      oprot.writeFieldEnd()
25062 
    if self.ex is not None:
25063 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25064 
      self.ex.write(oprot)
25065 
      oprot.writeFieldEnd()
25066 
    oprot.writeFieldStop()
25067 
    oprot.writeStructEnd()
25068 
 
25069 
  def validate(self):
25070 
    return
25071 
 
25072 
 
25073 
  def __repr__(self):
25074 
    L = ['%s=%r' % (key, value)
25075 
      for key, value in self.__dict__.iteritems()]
25076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25077 
 
25078 
  def __eq__(self, other):
25079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25080 
 
25081 
  def __ne__(self, other):
25082 
    return not (self == other)
25083 
 
25084 
class markEBSSettlementUploaded_args:
25085 
  """
25086 
  Attributes:
25087 
   - settlementId
25088 
  """
25089 
 
25090 
  thrift_spec = (
25091 
    None, # 0
25092 
    (1, TType.I64, 'settlementId', None, None, ), # 1
25093 
  )
25094 
 
25095 
  def __init__(self, settlementId=None,):
25096 
    self.settlementId = settlementId
25097 
 
25098 
  def read(self, iprot):
25099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25101 
      return
25102 
    iprot.readStructBegin()
25103 
    while True:
25104 
      (fname, ftype, fid) = iprot.readFieldBegin()
25105 
      if ftype == TType.STOP:
25106 
        break
25107 
      if fid == 1:
25108 
        if ftype == TType.I64:
25109 
          self.settlementId = iprot.readI64();
25110 
        else:
25111 
          iprot.skip(ftype)
25112 
      else:
25113 
        iprot.skip(ftype)
25114 
      iprot.readFieldEnd()
25115 
    iprot.readStructEnd()
25116 
 
25117 
  def write(self, oprot):
25118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25120 
      return
25121 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
25122 
    if self.settlementId is not None:
25123 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
25124 
      oprot.writeI64(self.settlementId)
25125 
      oprot.writeFieldEnd()
25126 
    oprot.writeFieldStop()
25127 
    oprot.writeStructEnd()
25128 
 
25129 
  def validate(self):
25130 
    return
25131 
 
25132 
 
25133 
  def __repr__(self):
25134 
    L = ['%s=%r' % (key, value)
25135 
      for key, value in self.__dict__.iteritems()]
25136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25137 
 
25138 
  def __eq__(self, other):
25139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25140 
 
25141 
  def __ne__(self, other):
25142 
    return not (self == other)
25143 
 
25144 
class markEBSSettlementUploaded_result:
25145 
  """
25146 
  Attributes:
25147 
   - ex
25148 
  """
25149 
 
25150 
  thrift_spec = (
25151 
    None, # 0
25152 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25153 
  )
25154 
 
25155 
  def __init__(self, ex=None,):
25156 
    self.ex = ex
25157 
 
25158 
  def read(self, iprot):
25159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25161 
      return
25162 
    iprot.readStructBegin()
25163 
    while True:
25164 
      (fname, ftype, fid) = iprot.readFieldBegin()
25165 
      if ftype == TType.STOP:
25166 
        break
25167 
      if fid == 1:
25168 
        if ftype == TType.STRUCT:
25169 
          self.ex = TransactionServiceException()
25170 
          self.ex.read(iprot)
25171 
        else:
25172 
          iprot.skip(ftype)
25173 
      else:
25174 
        iprot.skip(ftype)
25175 
      iprot.readFieldEnd()
25176 
    iprot.readStructEnd()
25177 
 
25178 
  def write(self, oprot):
25179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25181 
      return
25182 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
25183 
    if self.ex is not None:
25184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25185 
      self.ex.write(oprot)
25186 
      oprot.writeFieldEnd()
25187 
    oprot.writeFieldStop()
25188 
    oprot.writeStructEnd()
25189 
 
25190 
  def validate(self):
25191 
    return
25192 
 
25193 
 
25194 
  def __repr__(self):
25195 
    L = ['%s=%r' % (key, value)
25196 
      for key, value in self.__dict__.iteritems()]
25197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25198 
 
25199 
  def __eq__(self, other):
25200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25201 
 
25202 
  def __ne__(self, other):
25203 
    return not (self == other)
25204 
 
25205 
class getEBSSettlementDate_args:
25206 
  """
25207 
  Attributes:
25208 
   - settlementId
25209 
  """
25210 
 
25211 
  thrift_spec = (
25212 
    None, # 0
25213 
    (1, TType.I64, 'settlementId', None, None, ), # 1
25214 
  )
25215 
 
25216 
  def __init__(self, settlementId=None,):
25217 
    self.settlementId = settlementId
25218 
 
25219 
  def read(self, iprot):
25220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25222 
      return
25223 
    iprot.readStructBegin()
25224 
    while True:
25225 
      (fname, ftype, fid) = iprot.readFieldBegin()
25226 
      if ftype == TType.STOP:
25227 
        break
25228 
      if fid == 1:
25229 
        if ftype == TType.I64:
25230 
          self.settlementId = iprot.readI64();
25231 
        else:
25232 
          iprot.skip(ftype)
25233 
      else:
25234 
        iprot.skip(ftype)
25235 
      iprot.readFieldEnd()
25236 
    iprot.readStructEnd()
25237 
 
25238 
  def write(self, oprot):
25239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25241 
      return
25242 
    oprot.writeStructBegin('getEBSSettlementDate_args')
25243 
    if self.settlementId is not None:
25244 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
25245 
      oprot.writeI64(self.settlementId)
25246 
      oprot.writeFieldEnd()
25247 
    oprot.writeFieldStop()
25248 
    oprot.writeStructEnd()
25249 
 
25250 
  def validate(self):
25251 
    return
25252 
 
25253 
 
25254 
  def __repr__(self):
25255 
    L = ['%s=%r' % (key, value)
25256 
      for key, value in self.__dict__.iteritems()]
25257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25258 
 
25259 
  def __eq__(self, other):
25260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25261 
 
25262 
  def __ne__(self, other):
25263 
    return not (self == other)
25264 
 
25265 
class getEBSSettlementDate_result:
25266 
  """
25267 
  Attributes:
25268 
   - success
25269 
   - ex
25270 
  """
25271 
 
25272 
  thrift_spec = (
25273 
    (0, TType.I64, 'success', None, None, ), # 0
25274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25275 
  )
25276 
 
25277 
  def __init__(self, success=None, ex=None,):
25278 
    self.success = success
25279 
    self.ex = ex
25280 
 
25281 
  def read(self, iprot):
25282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25284 
      return
25285 
    iprot.readStructBegin()
25286 
    while True:
25287 
      (fname, ftype, fid) = iprot.readFieldBegin()
25288 
      if ftype == TType.STOP:
25289 
        break
25290 
      if fid == 0:
25291 
        if ftype == TType.I64:
25292 
          self.success = iprot.readI64();
25293 
        else:
25294 
          iprot.skip(ftype)
25295 
      elif fid == 1:
25296 
        if ftype == TType.STRUCT:
25297 
          self.ex = TransactionServiceException()
25298 
          self.ex.read(iprot)
25299 
        else:
25300 
          iprot.skip(ftype)
25301 
      else:
25302 
        iprot.skip(ftype)
25303 
      iprot.readFieldEnd()
25304 
    iprot.readStructEnd()
25305 
 
25306 
  def write(self, oprot):
25307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25309 
      return
25310 
    oprot.writeStructBegin('getEBSSettlementDate_result')
25311 
    if self.success is not None:
25312 
      oprot.writeFieldBegin('success', TType.I64, 0)
25313 
      oprot.writeI64(self.success)
25314 
      oprot.writeFieldEnd()
25315 
    if self.ex is not None:
25316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25317 
      self.ex.write(oprot)
25318 
      oprot.writeFieldEnd()
25319 
    oprot.writeFieldStop()
25320 
    oprot.writeStructEnd()
25321 
 
25322 
  def validate(self):
25323 
    return
25324 
 
25325 
 
25326 
  def __repr__(self):
25327 
    L = ['%s=%r' % (key, value)
25328 
      for key, value in self.__dict__.iteritems()]
25329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25330 
 
25331 
  def __eq__(self, other):
25332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25333 
 
25334 
  def __ne__(self, other):
25335 
    return not (self == other)
4715 varun.gupt 25336 
 
25337 
class getSettlementsByDate_args:
25338 
  """
25339 
  Attributes:
25340 
   - settlementDateFrom
25341 
   - settlementDateTo
25342 
   - isRefund
25343 
  """
25344 
 
25345 
  thrift_spec = (
25346 
    None, # 0
25347 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
25348 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
25349 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
25350 
  )
25351 
 
25352 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
25353 
    self.settlementDateFrom = settlementDateFrom
25354 
    self.settlementDateTo = settlementDateTo
25355 
    self.isRefund = isRefund
25356 
 
25357 
  def read(self, iprot):
25358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25360 
      return
25361 
    iprot.readStructBegin()
25362 
    while True:
25363 
      (fname, ftype, fid) = iprot.readFieldBegin()
25364 
      if ftype == TType.STOP:
25365 
        break
25366 
      if fid == 1:
25367 
        if ftype == TType.I64:
25368 
          self.settlementDateFrom = iprot.readI64();
25369 
        else:
25370 
          iprot.skip(ftype)
25371 
      elif fid == 2:
25372 
        if ftype == TType.I64:
25373 
          self.settlementDateTo = iprot.readI64();
25374 
        else:
25375 
          iprot.skip(ftype)
25376 
      elif fid == 3:
25377 
        if ftype == TType.BOOL:
25378 
          self.isRefund = iprot.readBool();
25379 
        else:
25380 
          iprot.skip(ftype)
25381 
      else:
25382 
        iprot.skip(ftype)
25383 
      iprot.readFieldEnd()
25384 
    iprot.readStructEnd()
25385 
 
25386 
  def write(self, oprot):
25387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25389 
      return
25390 
    oprot.writeStructBegin('getSettlementsByDate_args')
25391 
    if self.settlementDateFrom is not None:
25392 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
25393 
      oprot.writeI64(self.settlementDateFrom)
25394 
      oprot.writeFieldEnd()
25395 
    if self.settlementDateTo is not None:
25396 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
25397 
      oprot.writeI64(self.settlementDateTo)
25398 
      oprot.writeFieldEnd()
25399 
    if self.isRefund is not None:
25400 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
25401 
      oprot.writeBool(self.isRefund)
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 getSettlementsByDate_result:
25422 
  """
25423 
  Attributes:
25424 
   - success
25425 
   - ex
25426 
  """
25427 
 
25428 
  thrift_spec = (
25429 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
25430 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25431 
  )
25432 
 
25433 
  def __init__(self, success=None, ex=None,):
25434 
    self.success = success
25435 
    self.ex = ex
25436 
 
25437 
  def read(self, iprot):
25438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25440 
      return
25441 
    iprot.readStructBegin()
25442 
    while True:
25443 
      (fname, ftype, fid) = iprot.readFieldBegin()
25444 
      if ftype == TType.STOP:
25445 
        break
25446 
      if fid == 0:
25447 
        if ftype == TType.LIST:
25448 
          self.success = []
6188 rajveer 25449 
          (_etype566, _size563) = iprot.readListBegin()
25450 
          for _i567 in xrange(_size563):
25451 
            _elem568 = PaymentSettlement()
25452 
            _elem568.read(iprot)
25453 
            self.success.append(_elem568)
4715 varun.gupt 25454 
          iprot.readListEnd()
25455 
        else:
25456 
          iprot.skip(ftype)
25457 
      elif fid == 1:
25458 
        if ftype == TType.STRUCT:
25459 
          self.ex = TransactionServiceException()
25460 
          self.ex.read(iprot)
25461 
        else:
25462 
          iprot.skip(ftype)
25463 
      else:
25464 
        iprot.skip(ftype)
25465 
      iprot.readFieldEnd()
25466 
    iprot.readStructEnd()
25467 
 
25468 
  def write(self, oprot):
25469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25471 
      return
25472 
    oprot.writeStructBegin('getSettlementsByDate_result')
25473 
    if self.success is not None:
25474 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25475 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25476 
      for iter569 in self.success:
25477 
        iter569.write(oprot)
4715 varun.gupt 25478 
      oprot.writeListEnd()
25479 
      oprot.writeFieldEnd()
25480 
    if self.ex is not None:
25481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25482 
      self.ex.write(oprot)
25483 
      oprot.writeFieldEnd()
25484 
    oprot.writeFieldStop()
25485 
    oprot.writeStructEnd()
25486 
 
25487 
  def validate(self):
25488 
    return
25489 
 
25490 
 
25491 
  def __repr__(self):
25492 
    L = ['%s=%r' % (key, value)
25493 
      for key, value in self.__dict__.iteritems()]
25494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25495 
 
25496 
  def __eq__(self, other):
25497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25498 
 
25499 
  def __ne__(self, other):
25500 
    return not (self == other)
25501 
 
25502 
class getReshippedOrderIds_args:
25503 
  """
25504 
  Attributes:
25505 
   - orderIds
25506 
  """
25507 
 
25508 
  thrift_spec = (
25509 
    None, # 0
25510 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
25511 
  )
25512 
 
25513 
  def __init__(self, orderIds=None,):
25514 
    self.orderIds = orderIds
25515 
 
25516 
  def read(self, iprot):
25517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25519 
      return
25520 
    iprot.readStructBegin()
25521 
    while True:
25522 
      (fname, ftype, fid) = iprot.readFieldBegin()
25523 
      if ftype == TType.STOP:
25524 
        break
25525 
      if fid == 1:
25526 
        if ftype == TType.LIST:
25527 
          self.orderIds = []
6188 rajveer 25528 
          (_etype573, _size570) = iprot.readListBegin()
25529 
          for _i574 in xrange(_size570):
25530 
            _elem575 = iprot.readI64();
25531 
            self.orderIds.append(_elem575)
4715 varun.gupt 25532 
          iprot.readListEnd()
25533 
        else:
25534 
          iprot.skip(ftype)
25535 
      else:
25536 
        iprot.skip(ftype)
25537 
      iprot.readFieldEnd()
25538 
    iprot.readStructEnd()
25539 
 
25540 
  def write(self, oprot):
25541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25543 
      return
25544 
    oprot.writeStructBegin('getReshippedOrderIds_args')
25545 
    if self.orderIds is not None:
25546 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
25547 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 25548 
      for iter576 in self.orderIds:
25549 
        oprot.writeI64(iter576)
4715 varun.gupt 25550 
      oprot.writeListEnd()
25551 
      oprot.writeFieldEnd()
25552 
    oprot.writeFieldStop()
25553 
    oprot.writeStructEnd()
25554 
 
25555 
  def validate(self):
25556 
    return
25557 
 
25558 
 
25559 
  def __repr__(self):
25560 
    L = ['%s=%r' % (key, value)
25561 
      for key, value in self.__dict__.iteritems()]
25562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25563 
 
25564 
  def __eq__(self, other):
25565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25566 
 
25567 
  def __ne__(self, other):
25568 
    return not (self == other)
25569 
 
25570 
class getReshippedOrderIds_result:
25571 
  """
25572 
  Attributes:
25573 
   - success
25574 
   - ex
25575 
  """
25576 
 
25577 
  thrift_spec = (
25578 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25580 
  )
25581 
 
25582 
  def __init__(self, success=None, ex=None,):
25583 
    self.success = success
25584 
    self.ex = ex
25585 
 
25586 
  def read(self, iprot):
25587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25589 
      return
25590 
    iprot.readStructBegin()
25591 
    while True:
25592 
      (fname, ftype, fid) = iprot.readFieldBegin()
25593 
      if ftype == TType.STOP:
25594 
        break
25595 
      if fid == 0:
25596 
        if ftype == TType.LIST:
25597 
          self.success = []
6188 rajveer 25598 
          (_etype580, _size577) = iprot.readListBegin()
25599 
          for _i581 in xrange(_size577):
25600 
            _elem582 = iprot.readI64();
25601 
            self.success.append(_elem582)
4715 varun.gupt 25602 
          iprot.readListEnd()
25603 
        else:
25604 
          iprot.skip(ftype)
25605 
      elif fid == 1:
25606 
        if ftype == TType.STRUCT:
25607 
          self.ex = TransactionServiceException()
25608 
          self.ex.read(iprot)
25609 
        else:
25610 
          iprot.skip(ftype)
25611 
      else:
25612 
        iprot.skip(ftype)
25613 
      iprot.readFieldEnd()
25614 
    iprot.readStructEnd()
25615 
 
25616 
  def write(self, oprot):
25617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25619 
      return
25620 
    oprot.writeStructBegin('getReshippedOrderIds_result')
25621 
    if self.success is not None:
25622 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25623 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25624 
      for iter583 in self.success:
25625 
        oprot.writeI64(iter583)
4715 varun.gupt 25626 
      oprot.writeListEnd()
25627 
      oprot.writeFieldEnd()
25628 
    if self.ex is not None:
25629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25630 
      self.ex.write(oprot)
25631 
      oprot.writeFieldEnd()
25632 
    oprot.writeFieldStop()
25633 
    oprot.writeStructEnd()
25634 
 
25635 
  def validate(self):
25636 
    return
25637 
 
25638 
 
25639 
  def __repr__(self):
25640 
    L = ['%s=%r' % (key, value)
25641 
      for key, value in self.__dict__.iteritems()]
25642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25643 
 
25644 
  def __eq__(self, other):
25645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25646 
 
25647 
  def __ne__(self, other):
25648 
    return not (self == other)
4757 mandeep.dh 25649 
 
5481 phani.kuma 25650 
class getBilledOrders_args:
4875 varun.gupt 25651 
  """
25652 
  Attributes:
25653 
   - vendorId
5481 phani.kuma 25654 
   - onlyVendorNotPaid
25655 
   - billingDateFrom
25656 
   - billingDateTo
4875 varun.gupt 25657 
  """
25658 
 
25659 
  thrift_spec = (
25660 
    None, # 0
25661 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 25662 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
25663 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
25664 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 25665 
  )
25666 
 
5481 phani.kuma 25667 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 25668 
    self.vendorId = vendorId
5481 phani.kuma 25669 
    self.onlyVendorNotPaid = onlyVendorNotPaid
25670 
    self.billingDateFrom = billingDateFrom
25671 
    self.billingDateTo = billingDateTo
4875 varun.gupt 25672 
 
25673 
  def read(self, iprot):
25674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25676 
      return
25677 
    iprot.readStructBegin()
25678 
    while True:
25679 
      (fname, ftype, fid) = iprot.readFieldBegin()
25680 
      if ftype == TType.STOP:
25681 
        break
25682 
      if fid == 1:
25683 
        if ftype == TType.I64:
25684 
          self.vendorId = iprot.readI64();
25685 
        else:
25686 
          iprot.skip(ftype)
5481 phani.kuma 25687 
      elif fid == 2:
25688 
        if ftype == TType.BOOL:
25689 
          self.onlyVendorNotPaid = iprot.readBool();
25690 
        else:
25691 
          iprot.skip(ftype)
25692 
      elif fid == 3:
25693 
        if ftype == TType.I64:
25694 
          self.billingDateFrom = iprot.readI64();
25695 
        else:
25696 
          iprot.skip(ftype)
25697 
      elif fid == 4:
25698 
        if ftype == TType.I64:
25699 
          self.billingDateTo = iprot.readI64();
25700 
        else:
25701 
          iprot.skip(ftype)
4875 varun.gupt 25702 
      else:
25703 
        iprot.skip(ftype)
25704 
      iprot.readFieldEnd()
25705 
    iprot.readStructEnd()
25706 
 
25707 
  def write(self, oprot):
25708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25710 
      return
5481 phani.kuma 25711 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25712 
    if self.vendorId is not None:
25713 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25714 
      oprot.writeI64(self.vendorId)
25715 
      oprot.writeFieldEnd()
5481 phani.kuma 25716 
    if self.onlyVendorNotPaid is not None:
25717 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25718 
      oprot.writeBool(self.onlyVendorNotPaid)
25719 
      oprot.writeFieldEnd()
25720 
    if self.billingDateFrom is not None:
25721 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25722 
      oprot.writeI64(self.billingDateFrom)
25723 
      oprot.writeFieldEnd()
25724 
    if self.billingDateTo is not None:
25725 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25726 
      oprot.writeI64(self.billingDateTo)
25727 
      oprot.writeFieldEnd()
4875 varun.gupt 25728 
    oprot.writeFieldStop()
25729 
    oprot.writeStructEnd()
25730 
 
25731 
  def validate(self):
25732 
    return
25733 
 
25734 
 
25735 
  def __repr__(self):
25736 
    L = ['%s=%r' % (key, value)
25737 
      for key, value in self.__dict__.iteritems()]
25738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25739 
 
25740 
  def __eq__(self, other):
25741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25742 
 
25743 
  def __ne__(self, other):
25744 
    return not (self == other)
25745 
 
5481 phani.kuma 25746 
class getBilledOrders_result:
4875 varun.gupt 25747 
  """
25748 
  Attributes:
25749 
   - success
25750 
   - ex
25751 
  """
25752 
 
25753 
  thrift_spec = (
25754 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25755 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25756 
  )
25757 
 
25758 
  def __init__(self, success=None, ex=None,):
25759 
    self.success = success
25760 
    self.ex = ex
25761 
 
25762 
  def read(self, iprot):
25763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25765 
      return
25766 
    iprot.readStructBegin()
25767 
    while True:
25768 
      (fname, ftype, fid) = iprot.readFieldBegin()
25769 
      if ftype == TType.STOP:
25770 
        break
25771 
      if fid == 0:
25772 
        if ftype == TType.LIST:
25773 
          self.success = []
6188 rajveer 25774 
          (_etype587, _size584) = iprot.readListBegin()
25775 
          for _i588 in xrange(_size584):
25776 
            _elem589 = Order()
25777 
            _elem589.read(iprot)
25778 
            self.success.append(_elem589)
4875 varun.gupt 25779 
          iprot.readListEnd()
25780 
        else:
25781 
          iprot.skip(ftype)
25782 
      elif fid == 1:
25783 
        if ftype == TType.STRUCT:
25784 
          self.ex = TransactionServiceException()
25785 
          self.ex.read(iprot)
25786 
        else:
25787 
          iprot.skip(ftype)
25788 
      else:
25789 
        iprot.skip(ftype)
25790 
      iprot.readFieldEnd()
25791 
    iprot.readStructEnd()
25792 
 
25793 
  def write(self, oprot):
25794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25796 
      return
5481 phani.kuma 25797 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25798 
    if self.success is not None:
25799 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25800 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25801 
      for iter590 in self.success:
25802 
        iter590.write(oprot)
4875 varun.gupt 25803 
      oprot.writeListEnd()
25804 
      oprot.writeFieldEnd()
25805 
    if self.ex is not None:
25806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25807 
      self.ex.write(oprot)
25808 
      oprot.writeFieldEnd()
25809 
    oprot.writeFieldStop()
25810 
    oprot.writeStructEnd()
25811 
 
25812 
  def validate(self):
25813 
    return
25814 
 
25815 
 
25816 
  def __repr__(self):
25817 
    L = ['%s=%r' % (key, value)
25818 
      for key, value in self.__dict__.iteritems()]
25819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25820 
 
25821 
  def __eq__(self, other):
25822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25823 
 
25824 
  def __ne__(self, other):
25825 
    return not (self == other)
5031 varun.gupt 25826 
 
25827 
class getStatusDistributionOfOrders_args:
25828 
  """
25829 
  Attributes:
25830 
   - startDate
25831 
   - endDate
25832 
  """
25833 
 
25834 
  thrift_spec = (
25835 
    None, # 0
25836 
    (1, TType.I64, 'startDate', None, None, ), # 1
25837 
    (2, TType.I64, 'endDate', None, None, ), # 2
25838 
  )
25839 
 
25840 
  def __init__(self, startDate=None, endDate=None,):
25841 
    self.startDate = startDate
25842 
    self.endDate = endDate
25843 
 
25844 
  def read(self, iprot):
25845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25847 
      return
25848 
    iprot.readStructBegin()
25849 
    while True:
25850 
      (fname, ftype, fid) = iprot.readFieldBegin()
25851 
      if ftype == TType.STOP:
25852 
        break
25853 
      if fid == 1:
25854 
        if ftype == TType.I64:
25855 
          self.startDate = iprot.readI64();
25856 
        else:
25857 
          iprot.skip(ftype)
25858 
      elif fid == 2:
25859 
        if ftype == TType.I64:
25860 
          self.endDate = iprot.readI64();
25861 
        else:
25862 
          iprot.skip(ftype)
25863 
      else:
25864 
        iprot.skip(ftype)
25865 
      iprot.readFieldEnd()
25866 
    iprot.readStructEnd()
25867 
 
25868 
  def write(self, oprot):
25869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25871 
      return
25872 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25873 
    if self.startDate is not None:
25874 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25875 
      oprot.writeI64(self.startDate)
25876 
      oprot.writeFieldEnd()
25877 
    if self.endDate is not None:
25878 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25879 
      oprot.writeI64(self.endDate)
25880 
      oprot.writeFieldEnd()
25881 
    oprot.writeFieldStop()
25882 
    oprot.writeStructEnd()
25883 
 
25884 
  def validate(self):
25885 
    return
25886 
 
25887 
 
25888 
  def __repr__(self):
25889 
    L = ['%s=%r' % (key, value)
25890 
      for key, value in self.__dict__.iteritems()]
25891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25892 
 
25893 
  def __eq__(self, other):
25894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25895 
 
25896 
  def __ne__(self, other):
25897 
    return not (self == other)
25898 
 
25899 
class getStatusDistributionOfOrders_result:
25900 
  """
25901 
  Attributes:
25902 
   - success
25903 
   - ex
25904 
  """
25905 
 
25906 
  thrift_spec = (
25907 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25908 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25909 
  )
25910 
 
25911 
  def __init__(self, success=None, ex=None,):
25912 
    self.success = success
25913 
    self.ex = ex
25914 
 
25915 
  def read(self, iprot):
25916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25918 
      return
25919 
    iprot.readStructBegin()
25920 
    while True:
25921 
      (fname, ftype, fid) = iprot.readFieldBegin()
25922 
      if ftype == TType.STOP:
25923 
        break
25924 
      if fid == 0:
25925 
        if ftype == TType.MAP:
25926 
          self.success = {}
6188 rajveer 25927 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25928 
          for _i595 in xrange(_size591):
25929 
            _key596 = iprot.readI64();
25930 
            _val597 = iprot.readI64();
25931 
            self.success[_key596] = _val597
5031 varun.gupt 25932 
          iprot.readMapEnd()
25933 
        else:
25934 
          iprot.skip(ftype)
25935 
      elif fid == 1:
25936 
        if ftype == TType.STRUCT:
25937 
          self.ex = TransactionServiceException()
25938 
          self.ex.read(iprot)
25939 
        else:
25940 
          iprot.skip(ftype)
25941 
      else:
25942 
        iprot.skip(ftype)
25943 
      iprot.readFieldEnd()
25944 
    iprot.readStructEnd()
25945 
 
25946 
  def write(self, oprot):
25947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25949 
      return
25950 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25951 
    if self.success is not None:
25952 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25953 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25954 
      for kiter598,viter599 in self.success.items():
25955 
        oprot.writeI64(kiter598)
25956 
        oprot.writeI64(viter599)
5031 varun.gupt 25957 
      oprot.writeMapEnd()
25958 
      oprot.writeFieldEnd()
25959 
    if self.ex is not None:
25960 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25961 
      self.ex.write(oprot)
25962 
      oprot.writeFieldEnd()
25963 
    oprot.writeFieldStop()
25964 
    oprot.writeStructEnd()
25965 
 
25966 
  def validate(self):
25967 
    return
25968 
 
25969 
 
25970 
  def __repr__(self):
25971 
    L = ['%s=%r' % (key, value)
25972 
      for key, value in self.__dict__.iteritems()]
25973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25974 
 
25975 
  def __eq__(self, other):
25976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25977 
 
25978 
  def __ne__(self, other):
25979 
    return not (self == other)
5067 varun.gupt 25980 
 
25981 
class getOrderIdsForStatus_args:
25982 
  """
25983 
  Attributes:
25984 
   - status
25985 
   - startDatetime
25986 
   - endDatetime
25987 
  """
25988 
 
25989 
  thrift_spec = (
25990 
    None, # 0
25991 
    (1, TType.I64, 'status', None, None, ), # 1
25992 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25993 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25994 
  )
25995 
 
25996 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25997 
    self.status = status
25998 
    self.startDatetime = startDatetime
25999 
    self.endDatetime = endDatetime
26000 
 
26001 
  def read(self, iprot):
26002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26004 
      return
26005 
    iprot.readStructBegin()
26006 
    while True:
26007 
      (fname, ftype, fid) = iprot.readFieldBegin()
26008 
      if ftype == TType.STOP:
26009 
        break
26010 
      if fid == 1:
26011 
        if ftype == TType.I64:
26012 
          self.status = iprot.readI64();
26013 
        else:
26014 
          iprot.skip(ftype)
26015 
      elif fid == 2:
26016 
        if ftype == TType.I64:
26017 
          self.startDatetime = iprot.readI64();
26018 
        else:
26019 
          iprot.skip(ftype)
26020 
      elif fid == 3:
26021 
        if ftype == TType.I64:
26022 
          self.endDatetime = iprot.readI64();
26023 
        else:
26024 
          iprot.skip(ftype)
26025 
      else:
26026 
        iprot.skip(ftype)
26027 
      iprot.readFieldEnd()
26028 
    iprot.readStructEnd()
26029 
 
26030 
  def write(self, oprot):
26031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26033 
      return
26034 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
26035 
    if self.status is not None:
26036 
      oprot.writeFieldBegin('status', TType.I64, 1)
26037 
      oprot.writeI64(self.status)
26038 
      oprot.writeFieldEnd()
26039 
    if self.startDatetime is not None:
26040 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
26041 
      oprot.writeI64(self.startDatetime)
26042 
      oprot.writeFieldEnd()
26043 
    if self.endDatetime is not None:
26044 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
26045 
      oprot.writeI64(self.endDatetime)
26046 
      oprot.writeFieldEnd()
26047 
    oprot.writeFieldStop()
26048 
    oprot.writeStructEnd()
26049 
 
26050 
  def validate(self):
26051 
    return
26052 
 
26053 
 
26054 
  def __repr__(self):
26055 
    L = ['%s=%r' % (key, value)
26056 
      for key, value in self.__dict__.iteritems()]
26057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26058 
 
26059 
  def __eq__(self, other):
26060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26061 
 
26062 
  def __ne__(self, other):
26063 
    return not (self == other)
26064 
 
26065 
class getOrderIdsForStatus_result:
26066 
  """
26067 
  Attributes:
26068 
   - success
26069 
   - ex
26070 
  """
26071 
 
26072 
  thrift_spec = (
26073 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
26074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26075 
  )
26076 
 
26077 
  def __init__(self, success=None, ex=None,):
26078 
    self.success = success
26079 
    self.ex = ex
26080 
 
26081 
  def read(self, iprot):
26082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26084 
      return
26085 
    iprot.readStructBegin()
26086 
    while True:
26087 
      (fname, ftype, fid) = iprot.readFieldBegin()
26088 
      if ftype == TType.STOP:
26089 
        break
26090 
      if fid == 0:
26091 
        if ftype == TType.LIST:
26092 
          self.success = []
6188 rajveer 26093 
          (_etype603, _size600) = iprot.readListBegin()
26094 
          for _i604 in xrange(_size600):
26095 
            _elem605 = iprot.readI64();
26096 
            self.success.append(_elem605)
5067 varun.gupt 26097 
          iprot.readListEnd()
26098 
        else:
26099 
          iprot.skip(ftype)
26100 
      elif fid == 1:
26101 
        if ftype == TType.STRUCT:
26102 
          self.ex = TransactionServiceException()
26103 
          self.ex.read(iprot)
26104 
        else:
26105 
          iprot.skip(ftype)
26106 
      else:
26107 
        iprot.skip(ftype)
26108 
      iprot.readFieldEnd()
26109 
    iprot.readStructEnd()
26110 
 
26111 
  def write(self, oprot):
26112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26114 
      return
26115 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
26116 
    if self.success is not None:
26117 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26118 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 26119 
      for iter606 in self.success:
26120 
        oprot.writeI64(iter606)
5067 varun.gupt 26121 
      oprot.writeListEnd()
26122 
      oprot.writeFieldEnd()
26123 
    if self.ex is not None:
26124 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26125 
      self.ex.write(oprot)
26126 
      oprot.writeFieldEnd()
26127 
    oprot.writeFieldStop()
26128 
    oprot.writeStructEnd()
26129 
 
26130 
  def validate(self):
26131 
    return
26132 
 
26133 
 
26134 
  def __repr__(self):
26135 
    L = ['%s=%r' % (key, value)
26136 
      for key, value in self.__dict__.iteritems()]
26137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26138 
 
26139 
  def __eq__(self, other):
26140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26141 
 
26142 
  def __ne__(self, other):
26143 
    return not (self == other)
5099 varun.gupt 26144 
 
5348 anupam.sin 26145 
class updateCODAgent_args:
26146 
  """
26147 
  Attributes:
26148 
   - agent
26149 
   - orderId
26150 
  """
26151 
 
26152 
  thrift_spec = (
26153 
    None, # 0
26154 
    (1, TType.STRING, 'agent', None, None, ), # 1
26155 
    (2, TType.I64, 'orderId', None, None, ), # 2
26156 
  )
26157 
 
26158 
  def __init__(self, agent=None, orderId=None,):
26159 
    self.agent = agent
26160 
    self.orderId = orderId
26161 
 
26162 
  def read(self, iprot):
26163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26165 
      return
26166 
    iprot.readStructBegin()
26167 
    while True:
26168 
      (fname, ftype, fid) = iprot.readFieldBegin()
26169 
      if ftype == TType.STOP:
26170 
        break
26171 
      if fid == 1:
26172 
        if ftype == TType.STRING:
26173 
          self.agent = iprot.readString();
26174 
        else:
26175 
          iprot.skip(ftype)
26176 
      elif fid == 2:
26177 
        if ftype == TType.I64:
26178 
          self.orderId = iprot.readI64();
26179 
        else:
26180 
          iprot.skip(ftype)
26181 
      else:
26182 
        iprot.skip(ftype)
26183 
      iprot.readFieldEnd()
26184 
    iprot.readStructEnd()
26185 
 
26186 
  def write(self, oprot):
26187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26189 
      return
26190 
    oprot.writeStructBegin('updateCODAgent_args')
26191 
    if self.agent is not None:
26192 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
26193 
      oprot.writeString(self.agent)
26194 
      oprot.writeFieldEnd()
26195 
    if self.orderId is not None:
26196 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
26197 
      oprot.writeI64(self.orderId)
26198 
      oprot.writeFieldEnd()
26199 
    oprot.writeFieldStop()
26200 
    oprot.writeStructEnd()
26201 
 
26202 
  def validate(self):
26203 
    return
26204 
 
26205 
 
26206 
  def __repr__(self):
26207 
    L = ['%s=%r' % (key, value)
26208 
      for key, value in self.__dict__.iteritems()]
26209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26210 
 
26211 
  def __eq__(self, other):
26212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26213 
 
26214 
  def __ne__(self, other):
26215 
    return not (self == other)
26216 
 
26217 
class updateCODAgent_result:
26218 
  """
26219 
  Attributes:
26220 
   - ex
26221 
  """
26222 
 
26223 
  thrift_spec = (
26224 
    None, # 0
26225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26226 
  )
26227 
 
26228 
  def __init__(self, ex=None,):
26229 
    self.ex = ex
26230 
 
26231 
  def read(self, iprot):
26232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26234 
      return
26235 
    iprot.readStructBegin()
26236 
    while True:
26237 
      (fname, ftype, fid) = iprot.readFieldBegin()
26238 
      if ftype == TType.STOP:
26239 
        break
26240 
      if fid == 1:
26241 
        if ftype == TType.STRUCT:
26242 
          self.ex = TransactionServiceException()
26243 
          self.ex.read(iprot)
26244 
        else:
26245 
          iprot.skip(ftype)
26246 
      else:
26247 
        iprot.skip(ftype)
26248 
      iprot.readFieldEnd()
26249 
    iprot.readStructEnd()
26250 
 
26251 
  def write(self, oprot):
26252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26254 
      return
26255 
    oprot.writeStructBegin('updateCODAgent_result')
26256 
    if self.ex is not None:
26257 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26258 
      self.ex.write(oprot)
26259 
      oprot.writeFieldEnd()
26260 
    oprot.writeFieldStop()
26261 
    oprot.writeStructEnd()
26262 
 
26263 
  def validate(self):
26264 
    return
26265 
 
26266 
 
26267 
  def __repr__(self):
26268 
    L = ['%s=%r' % (key, value)
26269 
      for key, value in self.__dict__.iteritems()]
26270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26271 
 
26272 
  def __eq__(self, other):
26273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26274 
 
26275 
  def __ne__(self, other):
26276 
    return not (self == other)
26277 
 
5099 varun.gupt 26278 
class updateOrderAsPaidToVendor_args:
26279 
  """
26280 
  Attributes:
26281 
   - orderId
26282 
  """
26283 
 
26284 
  thrift_spec = (
26285 
    None, # 0
26286 
    (1, TType.I64, 'orderId', None, None, ), # 1
26287 
  )
26288 
 
26289 
  def __init__(self, orderId=None,):
26290 
    self.orderId = orderId
26291 
 
26292 
  def read(self, iprot):
26293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26295 
      return
26296 
    iprot.readStructBegin()
26297 
    while True:
26298 
      (fname, ftype, fid) = iprot.readFieldBegin()
26299 
      if ftype == TType.STOP:
26300 
        break
26301 
      if fid == 1:
26302 
        if ftype == TType.I64:
26303 
          self.orderId = iprot.readI64();
26304 
        else:
26305 
          iprot.skip(ftype)
26306 
      else:
26307 
        iprot.skip(ftype)
26308 
      iprot.readFieldEnd()
26309 
    iprot.readStructEnd()
26310 
 
26311 
  def write(self, oprot):
26312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26314 
      return
26315 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
26316 
    if self.orderId is not None:
26317 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26318 
      oprot.writeI64(self.orderId)
26319 
      oprot.writeFieldEnd()
26320 
    oprot.writeFieldStop()
26321 
    oprot.writeStructEnd()
26322 
 
26323 
  def validate(self):
26324 
    return
26325 
 
26326 
 
26327 
  def __repr__(self):
26328 
    L = ['%s=%r' % (key, value)
26329 
      for key, value in self.__dict__.iteritems()]
26330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26331 
 
26332 
  def __eq__(self, other):
26333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26334 
 
26335 
  def __ne__(self, other):
26336 
    return not (self == other)
26337 
 
26338 
class updateOrderAsPaidToVendor_result:
26339 
  """
26340 
  Attributes:
26341 
   - ex
26342 
  """
26343 
 
26344 
  thrift_spec = (
26345 
    None, # 0
26346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26347 
  )
26348 
 
26349 
  def __init__(self, ex=None,):
26350 
    self.ex = ex
26351 
 
26352 
  def read(self, iprot):
26353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26355 
      return
26356 
    iprot.readStructBegin()
26357 
    while True:
26358 
      (fname, ftype, fid) = iprot.readFieldBegin()
26359 
      if ftype == TType.STOP:
26360 
        break
26361 
      if fid == 1:
26362 
        if ftype == TType.STRUCT:
26363 
          self.ex = TransactionServiceException()
26364 
          self.ex.read(iprot)
26365 
        else:
26366 
          iprot.skip(ftype)
26367 
      else:
26368 
        iprot.skip(ftype)
26369 
      iprot.readFieldEnd()
26370 
    iprot.readStructEnd()
26371 
 
26372 
  def write(self, oprot):
26373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26375 
      return
26376 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
26377 
    if self.ex is not None:
26378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26379 
      self.ex.write(oprot)
26380 
      oprot.writeFieldEnd()
26381 
    oprot.writeFieldStop()
26382 
    oprot.writeStructEnd()
26383 
 
26384 
  def validate(self):
26385 
    return
26386 
 
26387 
 
26388 
  def __repr__(self):
26389 
    L = ['%s=%r' % (key, value)
26390 
      for key, value in self.__dict__.iteritems()]
26391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26392 
 
26393 
  def __eq__(self, other):
26394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26395 
 
26396 
  def __ne__(self, other):
26397 
    return not (self == other)
5208 varun.gupt 26398 
 
5386 phani.kuma 26399 
class updateOrderOnlyAsPaidToVendor_args:
26400 
  """
26401 
  Attributes:
26402 
   - orderId
26403 
  """
26404 
 
26405 
  thrift_spec = (
26406 
    None, # 0
26407 
    (1, TType.I64, 'orderId', None, None, ), # 1
26408 
  )
26409 
 
26410 
  def __init__(self, orderId=None,):
26411 
    self.orderId = orderId
26412 
 
26413 
  def read(self, iprot):
26414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26416 
      return
26417 
    iprot.readStructBegin()
26418 
    while True:
26419 
      (fname, ftype, fid) = iprot.readFieldBegin()
26420 
      if ftype == TType.STOP:
26421 
        break
26422 
      if fid == 1:
26423 
        if ftype == TType.I64:
26424 
          self.orderId = iprot.readI64();
26425 
        else:
26426 
          iprot.skip(ftype)
26427 
      else:
26428 
        iprot.skip(ftype)
26429 
      iprot.readFieldEnd()
26430 
    iprot.readStructEnd()
26431 
 
26432 
  def write(self, oprot):
26433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26435 
      return
26436 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
26437 
    if self.orderId is not None:
26438 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26439 
      oprot.writeI64(self.orderId)
26440 
      oprot.writeFieldEnd()
26441 
    oprot.writeFieldStop()
26442 
    oprot.writeStructEnd()
26443 
 
26444 
  def validate(self):
26445 
    return
26446 
 
26447 
 
26448 
  def __repr__(self):
26449 
    L = ['%s=%r' % (key, value)
26450 
      for key, value in self.__dict__.iteritems()]
26451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26452 
 
26453 
  def __eq__(self, other):
26454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26455 
 
26456 
  def __ne__(self, other):
26457 
    return not (self == other)
26458 
 
26459 
class updateOrderOnlyAsPaidToVendor_result:
26460 
  """
26461 
  Attributes:
26462 
   - ex
26463 
  """
26464 
 
26465 
  thrift_spec = (
26466 
    None, # 0
26467 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26468 
  )
26469 
 
26470 
  def __init__(self, ex=None,):
26471 
    self.ex = ex
26472 
 
26473 
  def read(self, iprot):
26474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26476 
      return
26477 
    iprot.readStructBegin()
26478 
    while True:
26479 
      (fname, ftype, fid) = iprot.readFieldBegin()
26480 
      if ftype == TType.STOP:
26481 
        break
26482 
      if fid == 1:
26483 
        if ftype == TType.STRUCT:
26484 
          self.ex = TransactionServiceException()
26485 
          self.ex.read(iprot)
26486 
        else:
26487 
          iprot.skip(ftype)
26488 
      else:
26489 
        iprot.skip(ftype)
26490 
      iprot.readFieldEnd()
26491 
    iprot.readStructEnd()
26492 
 
26493 
  def write(self, oprot):
26494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26496 
      return
26497 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
26498 
    if self.ex is not None:
26499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26500 
      self.ex.write(oprot)
26501 
      oprot.writeFieldEnd()
26502 
    oprot.writeFieldStop()
26503 
    oprot.writeStructEnd()
26504 
 
26505 
  def validate(self):
26506 
    return
26507 
 
26508 
 
26509 
  def __repr__(self):
26510 
    L = ['%s=%r' % (key, value)
26511 
      for key, value in self.__dict__.iteritems()]
26512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26513 
 
26514 
  def __eq__(self, other):
26515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26516 
 
26517 
  def __ne__(self, other):
26518 
    return not (self == other)
26519 
 
5208 varun.gupt 26520 
class getRefundedOrdersMarkedPaid_args:
26521 
 
26522 
  thrift_spec = (
26523 
  )
26524 
 
26525 
  def read(self, iprot):
26526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26528 
      return
26529 
    iprot.readStructBegin()
26530 
    while True:
26531 
      (fname, ftype, fid) = iprot.readFieldBegin()
26532 
      if ftype == TType.STOP:
26533 
        break
26534 
      else:
26535 
        iprot.skip(ftype)
26536 
      iprot.readFieldEnd()
26537 
    iprot.readStructEnd()
26538 
 
26539 
  def write(self, oprot):
26540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26542 
      return
26543 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
26544 
    oprot.writeFieldStop()
26545 
    oprot.writeStructEnd()
26546 
 
26547 
  def validate(self):
26548 
    return
26549 
 
26550 
 
26551 
  def __repr__(self):
26552 
    L = ['%s=%r' % (key, value)
26553 
      for key, value in self.__dict__.iteritems()]
26554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26555 
 
26556 
  def __eq__(self, other):
26557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26558 
 
26559 
  def __ne__(self, other):
26560 
    return not (self == other)
26561 
 
26562 
class getRefundedOrdersMarkedPaid_result:
26563 
  """
26564 
  Attributes:
26565 
   - success
26566 
   - ex
26567 
  """
26568 
 
26569 
  thrift_spec = (
26570 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26572 
  )
26573 
 
26574 
  def __init__(self, success=None, ex=None,):
26575 
    self.success = success
26576 
    self.ex = ex
26577 
 
26578 
  def read(self, iprot):
26579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26581 
      return
26582 
    iprot.readStructBegin()
26583 
    while True:
26584 
      (fname, ftype, fid) = iprot.readFieldBegin()
26585 
      if ftype == TType.STOP:
26586 
        break
26587 
      if fid == 0:
26588 
        if ftype == TType.LIST:
26589 
          self.success = []
6188 rajveer 26590 
          (_etype610, _size607) = iprot.readListBegin()
26591 
          for _i611 in xrange(_size607):
26592 
            _elem612 = Order()
26593 
            _elem612.read(iprot)
26594 
            self.success.append(_elem612)
5208 varun.gupt 26595 
          iprot.readListEnd()
26596 
        else:
26597 
          iprot.skip(ftype)
26598 
      elif fid == 1:
26599 
        if ftype == TType.STRUCT:
26600 
          self.ex = TransactionServiceException()
26601 
          self.ex.read(iprot)
26602 
        else:
26603 
          iprot.skip(ftype)
26604 
      else:
26605 
        iprot.skip(ftype)
26606 
      iprot.readFieldEnd()
26607 
    iprot.readStructEnd()
26608 
 
26609 
  def write(self, oprot):
26610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26612 
      return
26613 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
26614 
    if self.success is not None:
26615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26617 
      for iter613 in self.success:
26618 
        iter613.write(oprot)
5208 varun.gupt 26619 
      oprot.writeListEnd()
26620 
      oprot.writeFieldEnd()
26621 
    if self.ex is not None:
26622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26623 
      self.ex.write(oprot)
26624 
      oprot.writeFieldEnd()
26625 
    oprot.writeFieldStop()
26626 
    oprot.writeStructEnd()
26627 
 
26628 
  def validate(self):
26629 
    return
26630 
 
26631 
 
26632 
  def __repr__(self):
26633 
    L = ['%s=%r' % (key, value)
26634 
      for key, value in self.__dict__.iteritems()]
26635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26636 
 
26637 
  def __eq__(self, other):
26638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26639 
 
26640 
  def __ne__(self, other):
26641 
    return not (self == other)
5447 anupam.sin 26642 
 
26643 
class getAllVerificationAgents_args:
26644 
  """
26645 
  Attributes:
26646 
   - minOrderId
26647 
   - maxOrderId
26648 
  """
26649 
 
26650 
  thrift_spec = (
26651 
    None, # 0
26652 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
26653 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
26654 
  )
26655 
 
26656 
  def __init__(self, minOrderId=None, maxOrderId=None,):
26657 
    self.minOrderId = minOrderId
26658 
    self.maxOrderId = maxOrderId
26659 
 
26660 
  def read(self, iprot):
26661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26663 
      return
26664 
    iprot.readStructBegin()
26665 
    while True:
26666 
      (fname, ftype, fid) = iprot.readFieldBegin()
26667 
      if ftype == TType.STOP:
26668 
        break
26669 
      if fid == 1:
26670 
        if ftype == TType.I64:
26671 
          self.minOrderId = iprot.readI64();
26672 
        else:
26673 
          iprot.skip(ftype)
26674 
      elif fid == 2:
26675 
        if ftype == TType.I64:
26676 
          self.maxOrderId = iprot.readI64();
26677 
        else:
26678 
          iprot.skip(ftype)
26679 
      else:
26680 
        iprot.skip(ftype)
26681 
      iprot.readFieldEnd()
26682 
    iprot.readStructEnd()
26683 
 
26684 
  def write(self, oprot):
26685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26687 
      return
26688 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26689 
    if self.minOrderId is not None:
26690 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26691 
      oprot.writeI64(self.minOrderId)
26692 
      oprot.writeFieldEnd()
26693 
    if self.maxOrderId is not None:
26694 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26695 
      oprot.writeI64(self.maxOrderId)
26696 
      oprot.writeFieldEnd()
26697 
    oprot.writeFieldStop()
26698 
    oprot.writeStructEnd()
26699 
 
26700 
  def validate(self):
26701 
    return
26702 
 
26703 
 
26704 
  def __repr__(self):
26705 
    L = ['%s=%r' % (key, value)
26706 
      for key, value in self.__dict__.iteritems()]
26707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26708 
 
26709 
  def __eq__(self, other):
26710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26711 
 
26712 
  def __ne__(self, other):
26713 
    return not (self == other)
26714 
 
26715 
class getAllVerificationAgents_result:
26716 
  """
26717 
  Attributes:
26718 
   - success
26719 
  """
26720 
 
26721 
  thrift_spec = (
26722 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26723 
  )
26724 
 
26725 
  def __init__(self, success=None,):
26726 
    self.success = success
26727 
 
26728 
  def read(self, iprot):
26729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26731 
      return
26732 
    iprot.readStructBegin()
26733 
    while True:
26734 
      (fname, ftype, fid) = iprot.readFieldBegin()
26735 
      if ftype == TType.STOP:
26736 
        break
26737 
      if fid == 0:
26738 
        if ftype == TType.LIST:
26739 
          self.success = []
6188 rajveer 26740 
          (_etype617, _size614) = iprot.readListBegin()
26741 
          for _i618 in xrange(_size614):
26742 
            _elem619 = CODVerificationAgent()
26743 
            _elem619.read(iprot)
26744 
            self.success.append(_elem619)
5447 anupam.sin 26745 
          iprot.readListEnd()
26746 
        else:
26747 
          iprot.skip(ftype)
26748 
      else:
26749 
        iprot.skip(ftype)
26750 
      iprot.readFieldEnd()
26751 
    iprot.readStructEnd()
26752 
 
26753 
  def write(self, oprot):
26754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26756 
      return
26757 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26758 
    if self.success is not None:
26759 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26760 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26761 
      for iter620 in self.success:
26762 
        iter620.write(oprot)
5447 anupam.sin 26763 
      oprot.writeListEnd()
26764 
      oprot.writeFieldEnd()
26765 
    oprot.writeFieldStop()
26766 
    oprot.writeStructEnd()
26767 
 
26768 
  def validate(self):
26769 
    return
26770 
 
26771 
 
26772 
  def __repr__(self):
26773 
    L = ['%s=%r' % (key, value)
26774 
      for key, value in self.__dict__.iteritems()]
26775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26776 
 
26777 
  def __eq__(self, other):
26778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26779 
 
26780 
  def __ne__(self, other):
26781 
    return not (self == other)
5527 anupam.sin 26782 
 
26783 
class getAllAttributesForOrderId_args:
26784 
  """
26785 
  Attributes:
26786 
   - orderId
26787 
  """
26788 
 
26789 
  thrift_spec = (
26790 
    None, # 0
26791 
    (1, TType.I64, 'orderId', None, None, ), # 1
26792 
  )
26793 
 
26794 
  def __init__(self, orderId=None,):
26795 
    self.orderId = orderId
26796 
 
26797 
  def read(self, iprot):
26798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26800 
      return
26801 
    iprot.readStructBegin()
26802 
    while True:
26803 
      (fname, ftype, fid) = iprot.readFieldBegin()
26804 
      if ftype == TType.STOP:
26805 
        break
26806 
      if fid == 1:
26807 
        if ftype == TType.I64:
26808 
          self.orderId = iprot.readI64();
26809 
        else:
26810 
          iprot.skip(ftype)
26811 
      else:
26812 
        iprot.skip(ftype)
26813 
      iprot.readFieldEnd()
26814 
    iprot.readStructEnd()
26815 
 
26816 
  def write(self, oprot):
26817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26819 
      return
26820 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26821 
    if self.orderId is not None:
26822 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26823 
      oprot.writeI64(self.orderId)
26824 
      oprot.writeFieldEnd()
26825 
    oprot.writeFieldStop()
26826 
    oprot.writeStructEnd()
26827 
 
26828 
  def validate(self):
26829 
    return
26830 
 
26831 
 
26832 
  def __repr__(self):
26833 
    L = ['%s=%r' % (key, value)
26834 
      for key, value in self.__dict__.iteritems()]
26835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26836 
 
26837 
  def __eq__(self, other):
26838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26839 
 
26840 
  def __ne__(self, other):
26841 
    return not (self == other)
26842 
 
26843 
class getAllAttributesForOrderId_result:
26844 
  """
26845 
  Attributes:
26846 
   - success
26847 
  """
26848 
 
26849 
  thrift_spec = (
26850 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
26851 
  )
26852 
 
26853 
  def __init__(self, success=None,):
26854 
    self.success = success
26855 
 
26856 
  def read(self, iprot):
26857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26859 
      return
26860 
    iprot.readStructBegin()
26861 
    while True:
26862 
      (fname, ftype, fid) = iprot.readFieldBegin()
26863 
      if ftype == TType.STOP:
26864 
        break
26865 
      if fid == 0:
26866 
        if ftype == TType.LIST:
26867 
          self.success = []
6188 rajveer 26868 
          (_etype624, _size621) = iprot.readListBegin()
26869 
          for _i625 in xrange(_size621):
26870 
            _elem626 = Attribute()
26871 
            _elem626.read(iprot)
26872 
            self.success.append(_elem626)
5527 anupam.sin 26873 
          iprot.readListEnd()
26874 
        else:
26875 
          iprot.skip(ftype)
26876 
      else:
26877 
        iprot.skip(ftype)
26878 
      iprot.readFieldEnd()
26879 
    iprot.readStructEnd()
26880 
 
26881 
  def write(self, oprot):
26882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26884 
      return
26885 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26886 
    if self.success is not None:
26887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26888 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26889 
      for iter627 in self.success:
26890 
        iter627.write(oprot)
5527 anupam.sin 26891 
      oprot.writeListEnd()
26892 
      oprot.writeFieldEnd()
26893 
    oprot.writeFieldStop()
26894 
    oprot.writeStructEnd()
26895 
 
26896 
  def validate(self):
26897 
    return
26898 
 
26899 
 
26900 
  def __repr__(self):
26901 
    L = ['%s=%r' % (key, value)
26902 
      for key, value in self.__dict__.iteritems()]
26903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26904 
 
26905 
  def __eq__(self, other):
26906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26907 
 
26908 
  def __ne__(self, other):
26909 
    return not (self == other)
26910 
 
5676 rajveer 26911 
class setOrderAttributes_args:
26912 
  """
26913 
  Attributes:
26914 
   - orderId
26915 
   - attributes
26916 
  """
26917 
 
26918 
  thrift_spec = None
26919 
  def __init__(self, orderId=None, attributes=None,):
26920 
    self.orderId = orderId
26921 
    self.attributes = attributes
26922 
 
26923 
  def read(self, iprot):
26924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26926 
      return
26927 
    iprot.readStructBegin()
26928 
    while True:
26929 
      (fname, ftype, fid) = iprot.readFieldBegin()
26930 
      if ftype == TType.STOP:
26931 
        break
26932 
      if fid == 1:
26933 
        if ftype == TType.I64:
26934 
          self.orderId = iprot.readI64();
26935 
        else:
26936 
          iprot.skip(ftype)
26937 
      elif fid == -1:
26938 
        if ftype == TType.LIST:
26939 
          self.attributes = []
6188 rajveer 26940 
          (_etype631, _size628) = iprot.readListBegin()
26941 
          for _i632 in xrange(_size628):
26942 
            _elem633 = Attribute()
26943 
            _elem633.read(iprot)
26944 
            self.attributes.append(_elem633)
5676 rajveer 26945 
          iprot.readListEnd()
26946 
        else:
26947 
          iprot.skip(ftype)
26948 
      else:
26949 
        iprot.skip(ftype)
26950 
      iprot.readFieldEnd()
26951 
    iprot.readStructEnd()
26952 
 
26953 
  def write(self, oprot):
26954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26956 
      return
26957 
    oprot.writeStructBegin('setOrderAttributes_args')
26958 
    if self.attributes is not None:
26959 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26960 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26961 
      for iter634 in self.attributes:
26962 
        iter634.write(oprot)
5676 rajveer 26963 
      oprot.writeListEnd()
26964 
      oprot.writeFieldEnd()
26965 
    if self.orderId is not None:
26966 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26967 
      oprot.writeI64(self.orderId)
26968 
      oprot.writeFieldEnd()
26969 
    oprot.writeFieldStop()
26970 
    oprot.writeStructEnd()
26971 
 
26972 
  def validate(self):
26973 
    return
26974 
 
26975 
 
26976 
  def __repr__(self):
26977 
    L = ['%s=%r' % (key, value)
26978 
      for key, value in self.__dict__.iteritems()]
26979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26980 
 
26981 
  def __eq__(self, other):
26982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26983 
 
26984 
  def __ne__(self, other):
26985 
    return not (self == other)
26986 
 
26987 
class setOrderAttributes_result:
26988 
 
26989 
  thrift_spec = (
26990 
  )
26991 
 
26992 
  def read(self, iprot):
26993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26995 
      return
26996 
    iprot.readStructBegin()
26997 
    while True:
26998 
      (fname, ftype, fid) = iprot.readFieldBegin()
26999 
      if ftype == TType.STOP:
27000 
        break
27001 
      else:
27002 
        iprot.skip(ftype)
27003 
      iprot.readFieldEnd()
27004 
    iprot.readStructEnd()
27005 
 
27006 
  def write(self, oprot):
27007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27009 
      return
27010 
    oprot.writeStructBegin('setOrderAttributes_result')
27011 
    oprot.writeFieldStop()
27012 
    oprot.writeStructEnd()
27013 
 
27014 
  def validate(self):
27015 
    return
27016 
 
27017 
 
27018 
  def __repr__(self):
27019 
    L = ['%s=%r' % (key, value)
27020 
      for key, value in self.__dict__.iteritems()]
27021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27022 
 
27023 
  def __eq__(self, other):
27024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27025 
 
27026 
  def __ne__(self, other):
27027 
    return not (self == other)
27028 
 
5527 anupam.sin 27029 
class setOrderAttributeForTransaction_args:
27030 
  """
27031 
  Attributes:
27032 
   - transactionId
27033 
   - attribute
27034 
  """
27035 
 
27036 
  thrift_spec = None
27037 
  def __init__(self, transactionId=None, attribute=None,):
27038 
    self.transactionId = transactionId
27039 
    self.attribute = attribute
27040 
 
27041 
  def read(self, iprot):
27042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27044 
      return
27045 
    iprot.readStructBegin()
27046 
    while True:
27047 
      (fname, ftype, fid) = iprot.readFieldBegin()
27048 
      if ftype == TType.STOP:
27049 
        break
27050 
      if fid == 1:
27051 
        if ftype == TType.I64:
27052 
          self.transactionId = iprot.readI64();
27053 
        else:
27054 
          iprot.skip(ftype)
27055 
      elif fid == -1:
27056 
        if ftype == TType.STRUCT:
27057 
          self.attribute = Attribute()
27058 
          self.attribute.read(iprot)
27059 
        else:
27060 
          iprot.skip(ftype)
27061 
      else:
27062 
        iprot.skip(ftype)
27063 
      iprot.readFieldEnd()
27064 
    iprot.readStructEnd()
27065 
 
27066 
  def write(self, oprot):
27067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27069 
      return
27070 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
27071 
    if self.attribute is not None:
27072 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
27073 
      self.attribute.write(oprot)
27074 
      oprot.writeFieldEnd()
27075 
    if self.transactionId is not None:
27076 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
27077 
      oprot.writeI64(self.transactionId)
27078 
      oprot.writeFieldEnd()
27079 
    oprot.writeFieldStop()
27080 
    oprot.writeStructEnd()
27081 
 
27082 
  def validate(self):
27083 
    return
27084 
 
27085 
 
27086 
  def __repr__(self):
27087 
    L = ['%s=%r' % (key, value)
27088 
      for key, value in self.__dict__.iteritems()]
27089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27090 
 
27091 
  def __eq__(self, other):
27092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27093 
 
27094 
  def __ne__(self, other):
27095 
    return not (self == other)
27096 
 
27097 
class setOrderAttributeForTransaction_result:
27098 
 
27099 
  thrift_spec = (
27100 
  )
27101 
 
27102 
  def read(self, iprot):
27103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27105 
      return
27106 
    iprot.readStructBegin()
27107 
    while True:
27108 
      (fname, ftype, fid) = iprot.readFieldBegin()
27109 
      if ftype == TType.STOP:
27110 
        break
27111 
      else:
27112 
        iprot.skip(ftype)
27113 
      iprot.readFieldEnd()
27114 
    iprot.readStructEnd()
27115 
 
27116 
  def write(self, oprot):
27117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27119 
      return
27120 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
27121 
    oprot.writeFieldStop()
27122 
    oprot.writeStructEnd()
27123 
 
27124 
  def validate(self):
27125 
    return
27126 
 
27127 
 
27128 
  def __repr__(self):
27129 
    L = ['%s=%r' % (key, value)
27130 
      for key, value in self.__dict__.iteritems()]
27131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27132 
 
27133 
  def __eq__(self, other):
27134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27135 
 
27136 
  def __ne__(self, other):
27137 
    return not (self == other)
5553 rajveer 27138 
 
27139 
class getReceivePendingOrders_args:
27140 
  """
27141 
  Attributes:
27142 
   - storeId
27143 
  """
27144 
 
27145 
  thrift_spec = (
27146 
    None, # 0
27147 
    (1, TType.I64, 'storeId', None, None, ), # 1
27148 
  )
27149 
 
27150 
  def __init__(self, storeId=None,):
27151 
    self.storeId = storeId
27152 
 
27153 
  def read(self, iprot):
27154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27156 
      return
27157 
    iprot.readStructBegin()
27158 
    while True:
27159 
      (fname, ftype, fid) = iprot.readFieldBegin()
27160 
      if ftype == TType.STOP:
27161 
        break
27162 
      if fid == 1:
27163 
        if ftype == TType.I64:
27164 
          self.storeId = iprot.readI64();
27165 
        else:
27166 
          iprot.skip(ftype)
27167 
      else:
27168 
        iprot.skip(ftype)
27169 
      iprot.readFieldEnd()
27170 
    iprot.readStructEnd()
27171 
 
27172 
  def write(self, oprot):
27173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27175 
      return
27176 
    oprot.writeStructBegin('getReceivePendingOrders_args')
27177 
    if self.storeId is not None:
27178 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27179 
      oprot.writeI64(self.storeId)
27180 
      oprot.writeFieldEnd()
27181 
    oprot.writeFieldStop()
27182 
    oprot.writeStructEnd()
27183 
 
27184 
  def validate(self):
27185 
    return
27186 
 
27187 
 
27188 
  def __repr__(self):
27189 
    L = ['%s=%r' % (key, value)
27190 
      for key, value in self.__dict__.iteritems()]
27191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27192 
 
27193 
  def __eq__(self, other):
27194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27195 
 
27196 
  def __ne__(self, other):
27197 
    return not (self == other)
27198 
 
27199 
class getReceivePendingOrders_result:
27200 
  """
27201 
  Attributes:
27202 
   - success
27203 
  """
27204 
 
27205 
  thrift_spec = (
27206 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27207 
  )
27208 
 
27209 
  def __init__(self, success=None,):
27210 
    self.success = success
27211 
 
27212 
  def read(self, iprot):
27213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27215 
      return
27216 
    iprot.readStructBegin()
27217 
    while True:
27218 
      (fname, ftype, fid) = iprot.readFieldBegin()
27219 
      if ftype == TType.STOP:
27220 
        break
27221 
      if fid == 0:
27222 
        if ftype == TType.LIST:
27223 
          self.success = []
6188 rajveer 27224 
          (_etype638, _size635) = iprot.readListBegin()
27225 
          for _i639 in xrange(_size635):
27226 
            _elem640 = Order()
27227 
            _elem640.read(iprot)
27228 
            self.success.append(_elem640)
5553 rajveer 27229 
          iprot.readListEnd()
27230 
        else:
27231 
          iprot.skip(ftype)
27232 
      else:
27233 
        iprot.skip(ftype)
27234 
      iprot.readFieldEnd()
27235 
    iprot.readStructEnd()
27236 
 
27237 
  def write(self, oprot):
27238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27240 
      return
27241 
    oprot.writeStructBegin('getReceivePendingOrders_result')
27242 
    if self.success is not None:
27243 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27244 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27245 
      for iter641 in self.success:
27246 
        iter641.write(oprot)
5553 rajveer 27247 
      oprot.writeListEnd()
27248 
      oprot.writeFieldEnd()
27249 
    oprot.writeFieldStop()
27250 
    oprot.writeStructEnd()
27251 
 
27252 
  def validate(self):
27253 
    return
27254 
 
27255 
 
27256 
  def __repr__(self):
27257 
    L = ['%s=%r' % (key, value)
27258 
      for key, value in self.__dict__.iteritems()]
27259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27260 
 
27261 
  def __eq__(self, other):
27262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27263 
 
27264 
  def __ne__(self, other):
27265 
    return not (self == other)
27266 
 
27267 
class getReceivedAtStoreOrders_args:
27268 
  """
27269 
  Attributes:
27270 
   - storeId
27271 
  """
27272 
 
27273 
  thrift_spec = (
27274 
    None, # 0
27275 
    (1, TType.I64, 'storeId', None, None, ), # 1
27276 
  )
27277 
 
27278 
  def __init__(self, storeId=None,):
27279 
    self.storeId = storeId
27280 
 
27281 
  def read(self, iprot):
27282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27284 
      return
27285 
    iprot.readStructBegin()
27286 
    while True:
27287 
      (fname, ftype, fid) = iprot.readFieldBegin()
27288 
      if ftype == TType.STOP:
27289 
        break
27290 
      if fid == 1:
27291 
        if ftype == TType.I64:
27292 
          self.storeId = iprot.readI64();
27293 
        else:
27294 
          iprot.skip(ftype)
27295 
      else:
27296 
        iprot.skip(ftype)
27297 
      iprot.readFieldEnd()
27298 
    iprot.readStructEnd()
27299 
 
27300 
  def write(self, oprot):
27301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27303 
      return
27304 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
27305 
    if self.storeId is not None:
27306 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27307 
      oprot.writeI64(self.storeId)
27308 
      oprot.writeFieldEnd()
27309 
    oprot.writeFieldStop()
27310 
    oprot.writeStructEnd()
27311 
 
27312 
  def validate(self):
27313 
    return
27314 
 
27315 
 
27316 
  def __repr__(self):
27317 
    L = ['%s=%r' % (key, value)
27318 
      for key, value in self.__dict__.iteritems()]
27319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27320 
 
27321 
  def __eq__(self, other):
27322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27323 
 
27324 
  def __ne__(self, other):
27325 
    return not (self == other)
27326 
 
27327 
class getReceivedAtStoreOrders_result:
27328 
  """
27329 
  Attributes:
27330 
   - success
27331 
  """
27332 
 
27333 
  thrift_spec = (
27334 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27335 
  )
27336 
 
27337 
  def __init__(self, success=None,):
27338 
    self.success = success
27339 
 
27340 
  def read(self, iprot):
27341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27343 
      return
27344 
    iprot.readStructBegin()
27345 
    while True:
27346 
      (fname, ftype, fid) = iprot.readFieldBegin()
27347 
      if ftype == TType.STOP:
27348 
        break
27349 
      if fid == 0:
27350 
        if ftype == TType.LIST:
27351 
          self.success = []
6188 rajveer 27352 
          (_etype645, _size642) = iprot.readListBegin()
27353 
          for _i646 in xrange(_size642):
27354 
            _elem647 = Order()
27355 
            _elem647.read(iprot)
27356 
            self.success.append(_elem647)
5553 rajveer 27357 
          iprot.readListEnd()
27358 
        else:
27359 
          iprot.skip(ftype)
27360 
      else:
27361 
        iprot.skip(ftype)
27362 
      iprot.readFieldEnd()
27363 
    iprot.readStructEnd()
27364 
 
27365 
  def write(self, oprot):
27366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27368 
      return
27369 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
27370 
    if self.success is not None:
27371 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27372 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27373 
      for iter648 in self.success:
27374 
        iter648.write(oprot)
5553 rajveer 27375 
      oprot.writeListEnd()
27376 
      oprot.writeFieldEnd()
27377 
    oprot.writeFieldStop()
27378 
    oprot.writeStructEnd()
27379 
 
27380 
  def validate(self):
27381 
    return
27382 
 
27383 
 
27384 
  def __repr__(self):
27385 
    L = ['%s=%r' % (key, value)
27386 
      for key, value in self.__dict__.iteritems()]
27387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27388 
 
27389 
  def __eq__(self, other):
27390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27391 
 
27392 
  def __ne__(self, other):
27393 
    return not (self == other)
5593 mandeep.dh 27394 
 
5713 rajveer 27395 
class getOrdersCollectionAtStore_args:
27396 
  """
27397 
  Attributes:
27398 
   - storeId
27399 
   - fromDate
27400 
   - toDate
27401 
   - onlyCod
27402 
  """
27403 
 
27404 
  thrift_spec = (
27405 
    None, # 0
27406 
    (1, TType.I64, 'storeId', None, None, ), # 1
27407 
    (2, TType.I64, 'fromDate', None, None, ), # 2
27408 
    (3, TType.I64, 'toDate', None, None, ), # 3
27409 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
27410 
  )
27411 
 
27412 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
27413 
    self.storeId = storeId
27414 
    self.fromDate = fromDate
27415 
    self.toDate = toDate
27416 
    self.onlyCod = onlyCod
27417 
 
27418 
  def read(self, iprot):
27419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27421 
      return
27422 
    iprot.readStructBegin()
27423 
    while True:
27424 
      (fname, ftype, fid) = iprot.readFieldBegin()
27425 
      if ftype == TType.STOP:
27426 
        break
27427 
      if fid == 1:
27428 
        if ftype == TType.I64:
27429 
          self.storeId = iprot.readI64();
27430 
        else:
27431 
          iprot.skip(ftype)
27432 
      elif fid == 2:
27433 
        if ftype == TType.I64:
27434 
          self.fromDate = iprot.readI64();
27435 
        else:
27436 
          iprot.skip(ftype)
27437 
      elif fid == 3:
27438 
        if ftype == TType.I64:
27439 
          self.toDate = iprot.readI64();
27440 
        else:
27441 
          iprot.skip(ftype)
27442 
      elif fid == 4:
27443 
        if ftype == TType.BOOL:
27444 
          self.onlyCod = iprot.readBool();
27445 
        else:
27446 
          iprot.skip(ftype)
27447 
      else:
27448 
        iprot.skip(ftype)
27449 
      iprot.readFieldEnd()
27450 
    iprot.readStructEnd()
27451 
 
27452 
  def write(self, oprot):
27453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27455 
      return
27456 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
27457 
    if self.storeId is not None:
27458 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27459 
      oprot.writeI64(self.storeId)
27460 
      oprot.writeFieldEnd()
27461 
    if self.fromDate is not None:
27462 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
27463 
      oprot.writeI64(self.fromDate)
27464 
      oprot.writeFieldEnd()
27465 
    if self.toDate is not None:
27466 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
27467 
      oprot.writeI64(self.toDate)
27468 
      oprot.writeFieldEnd()
27469 
    if self.onlyCod is not None:
27470 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
27471 
      oprot.writeBool(self.onlyCod)
27472 
      oprot.writeFieldEnd()
27473 
    oprot.writeFieldStop()
27474 
    oprot.writeStructEnd()
27475 
 
27476 
  def validate(self):
27477 
    return
27478 
 
27479 
 
27480 
  def __repr__(self):
27481 
    L = ['%s=%r' % (key, value)
27482 
      for key, value in self.__dict__.iteritems()]
27483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27484 
 
27485 
  def __eq__(self, other):
27486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27487 
 
27488 
  def __ne__(self, other):
27489 
    return not (self == other)
27490 
 
27491 
class getOrdersCollectionAtStore_result:
27492 
  """
27493 
  Attributes:
27494 
   - success
27495 
  """
27496 
 
27497 
  thrift_spec = (
27498 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27499 
  )
27500 
 
27501 
  def __init__(self, success=None,):
27502 
    self.success = success
27503 
 
27504 
  def read(self, iprot):
27505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27507 
      return
27508 
    iprot.readStructBegin()
27509 
    while True:
27510 
      (fname, ftype, fid) = iprot.readFieldBegin()
27511 
      if ftype == TType.STOP:
27512 
        break
27513 
      if fid == 0:
27514 
        if ftype == TType.LIST:
27515 
          self.success = []
6188 rajveer 27516 
          (_etype652, _size649) = iprot.readListBegin()
27517 
          for _i653 in xrange(_size649):
27518 
            _elem654 = Order()
27519 
            _elem654.read(iprot)
27520 
            self.success.append(_elem654)
5713 rajveer 27521 
          iprot.readListEnd()
27522 
        else:
27523 
          iprot.skip(ftype)
27524 
      else:
27525 
        iprot.skip(ftype)
27526 
      iprot.readFieldEnd()
27527 
    iprot.readStructEnd()
27528 
 
27529 
  def write(self, oprot):
27530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27532 
      return
27533 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
27534 
    if self.success is not None:
27535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27536 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27537 
      for iter655 in self.success:
27538 
        iter655.write(oprot)
5713 rajveer 27539 
      oprot.writeListEnd()
27540 
      oprot.writeFieldEnd()
27541 
    oprot.writeFieldStop()
27542 
    oprot.writeStructEnd()
27543 
 
27544 
  def validate(self):
27545 
    return
27546 
 
27547 
 
27548 
  def __repr__(self):
27549 
    L = ['%s=%r' % (key, value)
27550 
      for key, value in self.__dict__.iteritems()]
27551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27552 
 
27553 
  def __eq__(self, other):
27554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27555 
 
27556 
  def __ne__(self, other):
27557 
    return not (self == other)
27558 
 
5833 rajveer 27559 
class getOrderAttributeValue_args:
27560 
  """
27561 
  Attributes:
27562 
   - orderId
27563 
   - attributeName
27564 
  """
27565 
 
27566 
  thrift_spec = None
27567 
  def __init__(self, orderId=None, attributeName=None,):
27568 
    self.orderId = orderId
27569 
    self.attributeName = attributeName
27570 
 
27571 
  def read(self, iprot):
27572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27574 
      return
27575 
    iprot.readStructBegin()
27576 
    while True:
27577 
      (fname, ftype, fid) = iprot.readFieldBegin()
27578 
      if ftype == TType.STOP:
27579 
        break
27580 
      if fid == 1:
27581 
        if ftype == TType.I64:
27582 
          self.orderId = iprot.readI64();
27583 
        else:
27584 
          iprot.skip(ftype)
27585 
      elif fid == -1:
27586 
        if ftype == TType.STRING:
27587 
          self.attributeName = iprot.readString();
27588 
        else:
27589 
          iprot.skip(ftype)
27590 
      else:
27591 
        iprot.skip(ftype)
27592 
      iprot.readFieldEnd()
27593 
    iprot.readStructEnd()
27594 
 
27595 
  def write(self, oprot):
27596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27598 
      return
27599 
    oprot.writeStructBegin('getOrderAttributeValue_args')
27600 
    if self.attributeName is not None:
27601 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
27602 
      oprot.writeString(self.attributeName)
27603 
      oprot.writeFieldEnd()
27604 
    if self.orderId is not None:
27605 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27606 
      oprot.writeI64(self.orderId)
27607 
      oprot.writeFieldEnd()
27608 
    oprot.writeFieldStop()
27609 
    oprot.writeStructEnd()
27610 
 
27611 
  def validate(self):
27612 
    return
27613 
 
27614 
 
27615 
  def __repr__(self):
27616 
    L = ['%s=%r' % (key, value)
27617 
      for key, value in self.__dict__.iteritems()]
27618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27619 
 
27620 
  def __eq__(self, other):
27621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27622 
 
27623 
  def __ne__(self, other):
27624 
    return not (self == other)
27625 
 
27626 
class getOrderAttributeValue_result:
27627 
  """
27628 
  Attributes:
27629 
   - success
27630 
  """
27631 
 
27632 
  thrift_spec = (
27633 
    (0, TType.STRING, 'success', None, None, ), # 0
27634 
  )
27635 
 
27636 
  def __init__(self, success=None,):
27637 
    self.success = success
27638 
 
27639 
  def read(self, iprot):
27640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27642 
      return
27643 
    iprot.readStructBegin()
27644 
    while True:
27645 
      (fname, ftype, fid) = iprot.readFieldBegin()
27646 
      if ftype == TType.STOP:
27647 
        break
27648 
      if fid == 0:
27649 
        if ftype == TType.STRING:
27650 
          self.success = iprot.readString();
27651 
        else:
27652 
          iprot.skip(ftype)
27653 
      else:
27654 
        iprot.skip(ftype)
27655 
      iprot.readFieldEnd()
27656 
    iprot.readStructEnd()
27657 
 
27658 
  def write(self, oprot):
27659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27661 
      return
27662 
    oprot.writeStructBegin('getOrderAttributeValue_result')
27663 
    if self.success is not None:
27664 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27665 
      oprot.writeString(self.success)
27666 
      oprot.writeFieldEnd()
27667 
    oprot.writeFieldStop()
27668 
    oprot.writeStructEnd()
27669 
 
27670 
  def validate(self):
27671 
    return
27672 
 
27673 
 
27674 
  def __repr__(self):
27675 
    L = ['%s=%r' % (key, value)
27676 
      for key, value in self.__dict__.iteritems()]
27677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27678 
 
27679 
  def __eq__(self, other):
27680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27681 
 
27682 
  def __ne__(self, other):
27683 
    return not (self == other)
27684 
 
6019 rajveer 27685 
class changeJacketNumber_args:
27686 
  """
27687 
  Attributes:
27688 
   - orderId
27689 
   - jacketNumber
27690 
  """
27691 
 
27692 
  thrift_spec = (
27693 
    None, # 0
27694 
    (1, TType.I64, 'orderId', None, None, ), # 1
27695 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27696 
  )
27697 
 
27698 
  def __init__(self, orderId=None, jacketNumber=None,):
27699 
    self.orderId = orderId
27700 
    self.jacketNumber = jacketNumber
27701 
 
27702 
  def read(self, iprot):
27703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27705 
      return
27706 
    iprot.readStructBegin()
27707 
    while True:
27708 
      (fname, ftype, fid) = iprot.readFieldBegin()
27709 
      if ftype == TType.STOP:
27710 
        break
27711 
      if fid == 1:
27712 
        if ftype == TType.I64:
27713 
          self.orderId = iprot.readI64();
27714 
        else:
27715 
          iprot.skip(ftype)
27716 
      elif fid == 2:
27717 
        if ftype == TType.I64:
27718 
          self.jacketNumber = iprot.readI64();
27719 
        else:
27720 
          iprot.skip(ftype)
27721 
      else:
27722 
        iprot.skip(ftype)
27723 
      iprot.readFieldEnd()
27724 
    iprot.readStructEnd()
27725 
 
27726 
  def write(self, oprot):
27727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27729 
      return
27730 
    oprot.writeStructBegin('changeJacketNumber_args')
27731 
    if self.orderId is not None:
27732 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27733 
      oprot.writeI64(self.orderId)
27734 
      oprot.writeFieldEnd()
27735 
    if self.jacketNumber is not None:
27736 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27737 
      oprot.writeI64(self.jacketNumber)
27738 
      oprot.writeFieldEnd()
27739 
    oprot.writeFieldStop()
27740 
    oprot.writeStructEnd()
27741 
 
27742 
  def validate(self):
27743 
    return
27744 
 
27745 
 
27746 
  def __repr__(self):
27747 
    L = ['%s=%r' % (key, value)
27748 
      for key, value in self.__dict__.iteritems()]
27749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27750 
 
27751 
  def __eq__(self, other):
27752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27753 
 
27754 
  def __ne__(self, other):
27755 
    return not (self == other)
27756 
 
27757 
class changeJacketNumber_result:
27758 
  """
27759 
  Attributes:
27760 
   - success
27761 
  """
27762 
 
27763 
  thrift_spec = (
27764 
    (0, TType.BOOL, 'success', None, None, ), # 0
27765 
  )
27766 
 
27767 
  def __init__(self, success=None,):
27768 
    self.success = success
27769 
 
27770 
  def read(self, iprot):
27771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27773 
      return
27774 
    iprot.readStructBegin()
27775 
    while True:
27776 
      (fname, ftype, fid) = iprot.readFieldBegin()
27777 
      if ftype == TType.STOP:
27778 
        break
27779 
      if fid == 0:
27780 
        if ftype == TType.BOOL:
27781 
          self.success = iprot.readBool();
27782 
        else:
27783 
          iprot.skip(ftype)
27784 
      else:
27785 
        iprot.skip(ftype)
27786 
      iprot.readFieldEnd()
27787 
    iprot.readStructEnd()
27788 
 
27789 
  def write(self, oprot):
27790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27792 
      return
27793 
    oprot.writeStructBegin('changeJacketNumber_result')
27794 
    if self.success is not None:
27795 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27796 
      oprot.writeBool(self.success)
27797 
      oprot.writeFieldEnd()
27798 
    oprot.writeFieldStop()
27799 
    oprot.writeStructEnd()
27800 
 
27801 
  def validate(self):
27802 
    return
27803 
 
27804 
 
27805 
  def __repr__(self):
27806 
    L = ['%s=%r' % (key, value)
27807 
      for key, value in self.__dict__.iteritems()]
27808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27809 
 
27810 
  def __eq__(self, other):
27811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27812 
 
27813 
  def __ne__(self, other):
27814 
    return not (self == other)
27815 
 
27816 
class markOrderAsRtoInTransit_args:
27817 
  """
27818 
  Attributes:
27819 
   - orderId
27820 
  """
27821 
 
27822 
  thrift_spec = (
27823 
    None, # 0
27824 
    (1, TType.I64, 'orderId', None, None, ), # 1
27825 
  )
27826 
 
27827 
  def __init__(self, orderId=None,):
27828 
    self.orderId = orderId
27829 
 
27830 
  def read(self, iprot):
27831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27833 
      return
27834 
    iprot.readStructBegin()
27835 
    while True:
27836 
      (fname, ftype, fid) = iprot.readFieldBegin()
27837 
      if ftype == TType.STOP:
27838 
        break
27839 
      if fid == 1:
27840 
        if ftype == TType.I64:
27841 
          self.orderId = iprot.readI64();
27842 
        else:
27843 
          iprot.skip(ftype)
27844 
      else:
27845 
        iprot.skip(ftype)
27846 
      iprot.readFieldEnd()
27847 
    iprot.readStructEnd()
27848 
 
27849 
  def write(self, oprot):
27850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27852 
      return
27853 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27854 
    if self.orderId is not None:
27855 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27856 
      oprot.writeI64(self.orderId)
27857 
      oprot.writeFieldEnd()
27858 
    oprot.writeFieldStop()
27859 
    oprot.writeStructEnd()
27860 
 
27861 
  def validate(self):
27862 
    return
27863 
 
27864 
 
27865 
  def __repr__(self):
27866 
    L = ['%s=%r' % (key, value)
27867 
      for key, value in self.__dict__.iteritems()]
27868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27869 
 
27870 
  def __eq__(self, other):
27871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27872 
 
27873 
  def __ne__(self, other):
27874 
    return not (self == other)
27875 
 
27876 
class markOrderAsRtoInTransit_result:
27877 
  """
27878 
  Attributes:
27879 
   - success
27880 
  """
27881 
 
27882 
  thrift_spec = (
27883 
    (0, TType.BOOL, 'success', None, None, ), # 0
27884 
  )
27885 
 
27886 
  def __init__(self, success=None,):
27887 
    self.success = success
27888 
 
27889 
  def read(self, iprot):
27890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27892 
      return
27893 
    iprot.readStructBegin()
27894 
    while True:
27895 
      (fname, ftype, fid) = iprot.readFieldBegin()
27896 
      if ftype == TType.STOP:
27897 
        break
27898 
      if fid == 0:
27899 
        if ftype == TType.BOOL:
27900 
          self.success = iprot.readBool();
27901 
        else:
27902 
          iprot.skip(ftype)
27903 
      else:
27904 
        iprot.skip(ftype)
27905 
      iprot.readFieldEnd()
27906 
    iprot.readStructEnd()
27907 
 
27908 
  def write(self, oprot):
27909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27911 
      return
27912 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
27913 
    if self.success is not None:
27914 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27915 
      oprot.writeBool(self.success)
27916 
      oprot.writeFieldEnd()
27917 
    oprot.writeFieldStop()
27918 
    oprot.writeStructEnd()
27919 
 
27920 
  def validate(self):
27921 
    return
27922 
 
27923 
 
27924 
  def __repr__(self):
27925 
    L = ['%s=%r' % (key, value)
27926 
      for key, value in self.__dict__.iteritems()]
27927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27928 
 
27929 
  def __eq__(self, other):
27930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27931 
 
27932 
  def __ne__(self, other):
27933 
    return not (self == other)
27934 
 
5593 mandeep.dh 27935 
class acceptOrderForItem_args:
27936 
  """
27937 
  Attributes:
27938 
   - itemId
27939 
   - quantity
27940 
   - fulfilmentWarehouseId
27941 
   - billingWarehouseId
27942 
  """
27943 
 
27944 
  thrift_spec = (
27945 
    None, # 0
27946 
    (1, TType.I64, 'itemId', None, None, ), # 1
27947 
    (2, TType.I64, 'quantity', None, None, ), # 2
27948 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27949 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27950 
  )
27951 
 
27952 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27953 
    self.itemId = itemId
27954 
    self.quantity = quantity
27955 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27956 
    self.billingWarehouseId = billingWarehouseId
27957 
 
27958 
  def read(self, iprot):
27959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27961 
      return
27962 
    iprot.readStructBegin()
27963 
    while True:
27964 
      (fname, ftype, fid) = iprot.readFieldBegin()
27965 
      if ftype == TType.STOP:
27966 
        break
27967 
      if fid == 1:
27968 
        if ftype == TType.I64:
27969 
          self.itemId = iprot.readI64();
27970 
        else:
27971 
          iprot.skip(ftype)
27972 
      elif fid == 2:
27973 
        if ftype == TType.I64:
27974 
          self.quantity = iprot.readI64();
27975 
        else:
27976 
          iprot.skip(ftype)
27977 
      elif fid == 3:
27978 
        if ftype == TType.I64:
27979 
          self.fulfilmentWarehouseId = iprot.readI64();
27980 
        else:
27981 
          iprot.skip(ftype)
27982 
      elif fid == 4:
27983 
        if ftype == TType.I64:
27984 
          self.billingWarehouseId = iprot.readI64();
27985 
        else:
27986 
          iprot.skip(ftype)
27987 
      else:
27988 
        iprot.skip(ftype)
27989 
      iprot.readFieldEnd()
27990 
    iprot.readStructEnd()
27991 
 
27992 
  def write(self, oprot):
27993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27995 
      return
27996 
    oprot.writeStructBegin('acceptOrderForItem_args')
27997 
    if self.itemId is not None:
27998 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27999 
      oprot.writeI64(self.itemId)
28000 
      oprot.writeFieldEnd()
28001 
    if self.quantity is not None:
28002 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
28003 
      oprot.writeI64(self.quantity)
28004 
      oprot.writeFieldEnd()
28005 
    if self.fulfilmentWarehouseId is not None:
28006 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
28007 
      oprot.writeI64(self.fulfilmentWarehouseId)
28008 
      oprot.writeFieldEnd()
28009 
    if self.billingWarehouseId is not None:
28010 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
28011 
      oprot.writeI64(self.billingWarehouseId)
28012 
      oprot.writeFieldEnd()
28013 
    oprot.writeFieldStop()
28014 
    oprot.writeStructEnd()
28015 
 
28016 
  def validate(self):
28017 
    return
28018 
 
28019 
 
28020 
  def __repr__(self):
28021 
    L = ['%s=%r' % (key, value)
28022 
      for key, value in self.__dict__.iteritems()]
28023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28024 
 
28025 
  def __eq__(self, other):
28026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28027 
 
28028 
  def __ne__(self, other):
28029 
    return not (self == other)
28030 
 
28031 
class acceptOrderForItem_result:
28032 
 
28033 
  thrift_spec = (
28034 
  )
28035 
 
28036 
  def read(self, iprot):
28037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28039 
      return
28040 
    iprot.readStructBegin()
28041 
    while True:
28042 
      (fname, ftype, fid) = iprot.readFieldBegin()
28043 
      if ftype == TType.STOP:
28044 
        break
28045 
      else:
28046 
        iprot.skip(ftype)
28047 
      iprot.readFieldEnd()
28048 
    iprot.readStructEnd()
28049 
 
28050 
  def write(self, oprot):
28051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28053 
      return
28054 
    oprot.writeStructBegin('acceptOrderForItem_result')
28055 
    oprot.writeFieldStop()
28056 
    oprot.writeStructEnd()
28057 
 
28058 
  def validate(self):
28059 
    return
28060 
 
28061 
 
28062 
  def __repr__(self):
28063 
    L = ['%s=%r' % (key, value)
28064 
      for key, value in self.__dict__.iteritems()]
28065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28066 
 
28067 
  def __eq__(self, other):
28068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28069 
 
28070 
  def __ne__(self, other):
28071 
    return not (self == other)
6000 mandeep.dh 28072 
 
28073 
class createRechargeOrder_args:
28074 
  """
28075 
  Attributes:
28076 
   - rechargeOrder
28077 
  """
28078 
 
28079 
  thrift_spec = (
28080 
    None, # 0
28081 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
28082 
  )
28083 
 
28084 
  def __init__(self, rechargeOrder=None,):
28085 
    self.rechargeOrder = rechargeOrder
28086 
 
28087 
  def read(self, iprot):
28088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28090 
      return
28091 
    iprot.readStructBegin()
28092 
    while True:
28093 
      (fname, ftype, fid) = iprot.readFieldBegin()
28094 
      if ftype == TType.STOP:
28095 
        break
28096 
      if fid == 1:
28097 
        if ftype == TType.STRUCT:
28098 
          self.rechargeOrder = RechargeOrder()
28099 
          self.rechargeOrder.read(iprot)
28100 
        else:
28101 
          iprot.skip(ftype)
28102 
      else:
28103 
        iprot.skip(ftype)
28104 
      iprot.readFieldEnd()
28105 
    iprot.readStructEnd()
28106 
 
28107 
  def write(self, oprot):
28108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28110 
      return
28111 
    oprot.writeStructBegin('createRechargeOrder_args')
28112 
    if self.rechargeOrder is not None:
28113 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
28114 
      self.rechargeOrder.write(oprot)
28115 
      oprot.writeFieldEnd()
28116 
    oprot.writeFieldStop()
28117 
    oprot.writeStructEnd()
28118 
 
28119 
  def validate(self):
28120 
    return
28121 
 
28122 
 
28123 
  def __repr__(self):
28124 
    L = ['%s=%r' % (key, value)
28125 
      for key, value in self.__dict__.iteritems()]
28126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28127 
 
28128 
  def __eq__(self, other):
28129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28130 
 
28131 
  def __ne__(self, other):
28132 
    return not (self == other)
28133 
 
28134 
class createRechargeOrder_result:
28135 
  """
28136 
  Attributes:
28137 
   - success
28138 
   - ex
28139 
  """
28140 
 
28141 
  thrift_spec = (
28142 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28144 
  )
28145 
 
28146 
  def __init__(self, success=None, ex=None,):
28147 
    self.success = success
28148 
    self.ex = ex
28149 
 
28150 
  def read(self, iprot):
28151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28153 
      return
28154 
    iprot.readStructBegin()
28155 
    while True:
28156 
      (fname, ftype, fid) = iprot.readFieldBegin()
28157 
      if ftype == TType.STOP:
28158 
        break
28159 
      if fid == 0:
28160 
        if ftype == TType.STRUCT:
28161 
          self.success = RechargeOrder()
28162 
          self.success.read(iprot)
28163 
        else:
28164 
          iprot.skip(ftype)
28165 
      elif fid == 1:
28166 
        if ftype == TType.STRUCT:
28167 
          self.ex = TransactionServiceException()
28168 
          self.ex.read(iprot)
28169 
        else:
28170 
          iprot.skip(ftype)
28171 
      else:
28172 
        iprot.skip(ftype)
28173 
      iprot.readFieldEnd()
28174 
    iprot.readStructEnd()
28175 
 
28176 
  def write(self, oprot):
28177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28179 
      return
28180 
    oprot.writeStructBegin('createRechargeOrder_result')
28181 
    if self.success is not None:
28182 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28183 
      self.success.write(oprot)
28184 
      oprot.writeFieldEnd()
28185 
    if self.ex is not None:
28186 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28187 
      self.ex.write(oprot)
28188 
      oprot.writeFieldEnd()
28189 
    oprot.writeFieldStop()
28190 
    oprot.writeStructEnd()
28191 
 
28192 
  def validate(self):
28193 
    return
28194 
 
28195 
 
28196 
  def __repr__(self):
28197 
    L = ['%s=%r' % (key, value)
28198 
      for key, value in self.__dict__.iteritems()]
28199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28200 
 
28201 
  def __eq__(self, other):
28202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28203 
 
28204 
  def __ne__(self, other):
28205 
    return not (self == other)
28206 
 
6031 rajveer 28207 
class getRechargeOrder_args:
28208 
  """
28209 
  Attributes:
28210 
   - rechargeRrderId
28211 
  """
28212 
 
28213 
  thrift_spec = (
28214 
    None, # 0
28215 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
28216 
  )
28217 
 
28218 
  def __init__(self, rechargeRrderId=None,):
28219 
    self.rechargeRrderId = rechargeRrderId
28220 
 
28221 
  def read(self, iprot):
28222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28224 
      return
28225 
    iprot.readStructBegin()
28226 
    while True:
28227 
      (fname, ftype, fid) = iprot.readFieldBegin()
28228 
      if ftype == TType.STOP:
28229 
        break
28230 
      if fid == 1:
28231 
        if ftype == TType.I64:
28232 
          self.rechargeRrderId = iprot.readI64();
28233 
        else:
28234 
          iprot.skip(ftype)
28235 
      else:
28236 
        iprot.skip(ftype)
28237 
      iprot.readFieldEnd()
28238 
    iprot.readStructEnd()
28239 
 
28240 
  def write(self, oprot):
28241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28243 
      return
28244 
    oprot.writeStructBegin('getRechargeOrder_args')
28245 
    if self.rechargeRrderId is not None:
28246 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
28247 
      oprot.writeI64(self.rechargeRrderId)
28248 
      oprot.writeFieldEnd()
28249 
    oprot.writeFieldStop()
28250 
    oprot.writeStructEnd()
28251 
 
28252 
  def validate(self):
28253 
    return
28254 
 
28255 
 
28256 
  def __repr__(self):
28257 
    L = ['%s=%r' % (key, value)
28258 
      for key, value in self.__dict__.iteritems()]
28259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28260 
 
28261 
  def __eq__(self, other):
28262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28263 
 
28264 
  def __ne__(self, other):
28265 
    return not (self == other)
28266 
 
28267 
class getRechargeOrder_result:
28268 
  """
28269 
  Attributes:
28270 
   - success
28271 
   - ex
28272 
  """
28273 
 
28274 
  thrift_spec = (
28275 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28276 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28277 
  )
28278 
 
28279 
  def __init__(self, success=None, ex=None,):
28280 
    self.success = success
28281 
    self.ex = ex
28282 
 
28283 
  def read(self, iprot):
28284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28286 
      return
28287 
    iprot.readStructBegin()
28288 
    while True:
28289 
      (fname, ftype, fid) = iprot.readFieldBegin()
28290 
      if ftype == TType.STOP:
28291 
        break
28292 
      if fid == 0:
28293 
        if ftype == TType.STRUCT:
28294 
          self.success = RechargeOrder()
28295 
          self.success.read(iprot)
28296 
        else:
28297 
          iprot.skip(ftype)
28298 
      elif fid == 1:
28299 
        if ftype == TType.STRUCT:
28300 
          self.ex = TransactionServiceException()
28301 
          self.ex.read(iprot)
28302 
        else:
28303 
          iprot.skip(ftype)
28304 
      else:
28305 
        iprot.skip(ftype)
28306 
      iprot.readFieldEnd()
28307 
    iprot.readStructEnd()
28308 
 
28309 
  def write(self, oprot):
28310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28312 
      return
28313 
    oprot.writeStructBegin('getRechargeOrder_result')
28314 
    if self.success is not None:
28315 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28316 
      self.success.write(oprot)
28317 
      oprot.writeFieldEnd()
28318 
    if self.ex is not None:
28319 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28320 
      self.ex.write(oprot)
28321 
      oprot.writeFieldEnd()
28322 
    oprot.writeFieldStop()
28323 
    oprot.writeStructEnd()
28324 
 
28325 
  def validate(self):
28326 
    return
28327 
 
28328 
 
28329 
  def __repr__(self):
28330 
    L = ['%s=%r' % (key, value)
28331 
      for key, value in self.__dict__.iteritems()]
28332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28333 
 
28334 
  def __eq__(self, other):
28335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28336 
 
28337 
  def __ne__(self, other):
28338 
    return not (self == other)
28339 
 
28340 
class getRechargeOrders_args:
28341 
  """
28342 
  Attributes:
28343 
   - userId
28344 
  """
28345 
 
28346 
  thrift_spec = (
28347 
    None, # 0
28348 
    (1, TType.I64, 'userId', None, None, ), # 1
28349 
  )
28350 
 
28351 
  def __init__(self, userId=None,):
28352 
    self.userId = userId
28353 
 
28354 
  def read(self, iprot):
28355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28357 
      return
28358 
    iprot.readStructBegin()
28359 
    while True:
28360 
      (fname, ftype, fid) = iprot.readFieldBegin()
28361 
      if ftype == TType.STOP:
28362 
        break
28363 
      if fid == 1:
28364 
        if ftype == TType.I64:
28365 
          self.userId = iprot.readI64();
28366 
        else:
28367 
          iprot.skip(ftype)
28368 
      else:
28369 
        iprot.skip(ftype)
28370 
      iprot.readFieldEnd()
28371 
    iprot.readStructEnd()
28372 
 
28373 
  def write(self, oprot):
28374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28376 
      return
28377 
    oprot.writeStructBegin('getRechargeOrders_args')
28378 
    if self.userId is not None:
28379 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28380 
      oprot.writeI64(self.userId)
28381 
      oprot.writeFieldEnd()
28382 
    oprot.writeFieldStop()
28383 
    oprot.writeStructEnd()
28384 
 
28385 
  def validate(self):
28386 
    return
28387 
 
28388 
 
28389 
  def __repr__(self):
28390 
    L = ['%s=%r' % (key, value)
28391 
      for key, value in self.__dict__.iteritems()]
28392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28393 
 
28394 
  def __eq__(self, other):
28395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28396 
 
28397 
  def __ne__(self, other):
28398 
    return not (self == other)
28399 
 
28400 
class getRechargeOrders_result:
28401 
  """
28402 
  Attributes:
28403 
   - success
28404 
  """
28405 
 
28406 
  thrift_spec = (
28407 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28408 
  )
28409 
 
28410 
  def __init__(self, success=None,):
28411 
    self.success = success
28412 
 
28413 
  def read(self, iprot):
28414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28416 
      return
28417 
    iprot.readStructBegin()
28418 
    while True:
28419 
      (fname, ftype, fid) = iprot.readFieldBegin()
28420 
      if ftype == TType.STOP:
28421 
        break
28422 
      if fid == 0:
28423 
        if ftype == TType.LIST:
28424 
          self.success = []
6188 rajveer 28425 
          (_etype659, _size656) = iprot.readListBegin()
28426 
          for _i660 in xrange(_size656):
28427 
            _elem661 = RechargeOrder()
28428 
            _elem661.read(iprot)
28429 
            self.success.append(_elem661)
6031 rajveer 28430 
          iprot.readListEnd()
28431 
        else:
28432 
          iprot.skip(ftype)
28433 
      else:
28434 
        iprot.skip(ftype)
28435 
      iprot.readFieldEnd()
28436 
    iprot.readStructEnd()
28437 
 
28438 
  def write(self, oprot):
28439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28441 
      return
28442 
    oprot.writeStructBegin('getRechargeOrders_result')
28443 
    if self.success is not None:
28444 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28445 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28446 
      for iter662 in self.success:
28447 
        iter662.write(oprot)
6031 rajveer 28448 
      oprot.writeListEnd()
28449 
      oprot.writeFieldEnd()
28450 
    oprot.writeFieldStop()
28451 
    oprot.writeStructEnd()
28452 
 
28453 
  def validate(self):
28454 
    return
28455 
 
28456 
 
28457 
  def __repr__(self):
28458 
    L = ['%s=%r' % (key, value)
28459 
      for key, value in self.__dict__.iteritems()]
28460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28461 
 
28462 
  def __eq__(self, other):
28463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28464 
 
28465 
  def __ne__(self, other):
28466 
    return not (self == other)
28467 
 
6000 mandeep.dh 28468 
class updateRechargeOrderStatus_args:
28469 
  """
28470 
  Attributes:
28471 
   - rechargeOrderId
28472 
   - rechargeOrderStatus
28473 
  """
28474 
 
28475 
  thrift_spec = (
28476 
    None, # 0
28477 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
28478 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
28479 
  )
28480 
 
28481 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
28482 
    self.rechargeOrderId = rechargeOrderId
28483 
    self.rechargeOrderStatus = rechargeOrderStatus
28484 
 
28485 
  def read(self, iprot):
28486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28488 
      return
28489 
    iprot.readStructBegin()
28490 
    while True:
28491 
      (fname, ftype, fid) = iprot.readFieldBegin()
28492 
      if ftype == TType.STOP:
28493 
        break
28494 
      if fid == 1:
28495 
        if ftype == TType.I64:
28496 
          self.rechargeOrderId = iprot.readI64();
28497 
        else:
28498 
          iprot.skip(ftype)
28499 
      elif fid == 2:
28500 
        if ftype == TType.I32:
28501 
          self.rechargeOrderStatus = iprot.readI32();
28502 
        else:
28503 
          iprot.skip(ftype)
28504 
      else:
28505 
        iprot.skip(ftype)
28506 
      iprot.readFieldEnd()
28507 
    iprot.readStructEnd()
28508 
 
28509 
  def write(self, oprot):
28510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28512 
      return
28513 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
28514 
    if self.rechargeOrderId is not None:
28515 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28516 
      oprot.writeI64(self.rechargeOrderId)
28517 
      oprot.writeFieldEnd()
28518 
    if self.rechargeOrderStatus is not None:
28519 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
28520 
      oprot.writeI32(self.rechargeOrderStatus)
28521 
      oprot.writeFieldEnd()
28522 
    oprot.writeFieldStop()
28523 
    oprot.writeStructEnd()
28524 
 
28525 
  def validate(self):
28526 
    return
28527 
 
28528 
 
28529 
  def __repr__(self):
28530 
    L = ['%s=%r' % (key, value)
28531 
      for key, value in self.__dict__.iteritems()]
28532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28533 
 
28534 
  def __eq__(self, other):
28535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28536 
 
28537 
  def __ne__(self, other):
28538 
    return not (self == other)
28539 
 
28540 
class updateRechargeOrderStatus_result:
28541 
  """
28542 
  Attributes:
6031 rajveer 28543 
   - success
6000 mandeep.dh 28544 
   - ex
28545 
  """
28546 
 
28547 
  thrift_spec = (
6031 rajveer 28548 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28550 
  )
28551 
 
6031 rajveer 28552 
  def __init__(self, success=None, ex=None,):
28553 
    self.success = success
6000 mandeep.dh 28554 
    self.ex = ex
28555 
 
28556 
  def read(self, iprot):
28557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28559 
      return
28560 
    iprot.readStructBegin()
28561 
    while True:
28562 
      (fname, ftype, fid) = iprot.readFieldBegin()
28563 
      if ftype == TType.STOP:
28564 
        break
6031 rajveer 28565 
      if fid == 0:
28566 
        if ftype == TType.BOOL:
28567 
          self.success = iprot.readBool();
28568 
        else:
28569 
          iprot.skip(ftype)
28570 
      elif fid == 1:
6000 mandeep.dh 28571 
        if ftype == TType.STRUCT:
28572 
          self.ex = TransactionServiceException()
28573 
          self.ex.read(iprot)
28574 
        else:
28575 
          iprot.skip(ftype)
28576 
      else:
28577 
        iprot.skip(ftype)
28578 
      iprot.readFieldEnd()
28579 
    iprot.readStructEnd()
28580 
 
28581 
  def write(self, oprot):
28582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28584 
      return
28585 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 28586 
    if self.success is not None:
28587 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28588 
      oprot.writeBool(self.success)
28589 
      oprot.writeFieldEnd()
6000 mandeep.dh 28590 
    if self.ex is not None:
28591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28592 
      self.ex.write(oprot)
28593 
      oprot.writeFieldEnd()
28594 
    oprot.writeFieldStop()
28595 
    oprot.writeStructEnd()
28596 
 
28597 
  def validate(self):
28598 
    return
28599 
 
28600 
 
28601 
  def __repr__(self):
28602 
    L = ['%s=%r' % (key, value)
28603 
      for key, value in self.__dict__.iteritems()]
28604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28605 
 
28606 
  def __eq__(self, other):
28607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28608 
 
28609 
  def __ne__(self, other):
28610 
    return not (self == other)
28611 
 
28612 
class activateRechargeTxn_args:
28613 
  """
28614 
  Attributes:
6031 rajveer 28615 
   - rechargeOrderId
6000 mandeep.dh 28616 
  """
28617 
 
28618 
  thrift_spec = (
28619 
    None, # 0
6031 rajveer 28620 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 28621 
  )
28622 
 
6031 rajveer 28623 
  def __init__(self, rechargeOrderId=None,):
28624 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 28625 
 
28626 
  def read(self, iprot):
28627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28629 
      return
28630 
    iprot.readStructBegin()
28631 
    while True:
28632 
      (fname, ftype, fid) = iprot.readFieldBegin()
28633 
      if ftype == TType.STOP:
28634 
        break
28635 
      if fid == 1:
6031 rajveer 28636 
        if ftype == TType.I64:
28637 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 28638 
        else:
28639 
          iprot.skip(ftype)
28640 
      else:
28641 
        iprot.skip(ftype)
28642 
      iprot.readFieldEnd()
28643 
    iprot.readStructEnd()
28644 
 
28645 
  def write(self, oprot):
28646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28648 
      return
28649 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 28650 
    if self.rechargeOrderId is not None:
28651 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28652 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 28653 
      oprot.writeFieldEnd()
28654 
    oprot.writeFieldStop()
28655 
    oprot.writeStructEnd()
28656 
 
28657 
  def validate(self):
28658 
    return
28659 
 
28660 
 
28661 
  def __repr__(self):
28662 
    L = ['%s=%r' % (key, value)
28663 
      for key, value in self.__dict__.iteritems()]
28664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28665 
 
28666 
  def __eq__(self, other):
28667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28668 
 
28669 
  def __ne__(self, other):
28670 
    return not (self == other)
28671 
 
28672 
class activateRechargeTxn_result:
28673 
  """
28674 
  Attributes:
28675 
   - success
28676 
   - ex
28677 
  """
28678 
 
28679 
  thrift_spec = (
6031 rajveer 28680 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28681 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28682 
  )
28683 
 
28684 
  def __init__(self, success=None, ex=None,):
28685 
    self.success = success
28686 
    self.ex = ex
28687 
 
28688 
  def read(self, iprot):
28689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28691 
      return
28692 
    iprot.readStructBegin()
28693 
    while True:
28694 
      (fname, ftype, fid) = iprot.readFieldBegin()
28695 
      if ftype == TType.STOP:
28696 
        break
28697 
      if fid == 0:
6031 rajveer 28698 
        if ftype == TType.BOOL:
28699 
          self.success = iprot.readBool();
6000 mandeep.dh 28700 
        else:
28701 
          iprot.skip(ftype)
28702 
      elif fid == 1:
28703 
        if ftype == TType.STRUCT:
28704 
          self.ex = TransactionServiceException()
28705 
          self.ex.read(iprot)
28706 
        else:
28707 
          iprot.skip(ftype)
28708 
      else:
28709 
        iprot.skip(ftype)
28710 
      iprot.readFieldEnd()
28711 
    iprot.readStructEnd()
28712 
 
28713 
  def write(self, oprot):
28714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28716 
      return
28717 
    oprot.writeStructBegin('activateRechargeTxn_result')
28718 
    if self.success is not None:
6031 rajveer 28719 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28720 
      oprot.writeBool(self.success)
6000 mandeep.dh 28721 
      oprot.writeFieldEnd()
28722 
    if self.ex is not None:
28723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28724 
      self.ex.write(oprot)
28725 
      oprot.writeFieldEnd()
28726 
    oprot.writeFieldStop()
28727 
    oprot.writeStructEnd()
28728 
 
28729 
  def validate(self):
28730 
    return
28731 
 
28732 
 
28733 
  def __repr__(self):
28734 
    L = ['%s=%r' % (key, value)
28735 
      for key, value in self.__dict__.iteritems()]
28736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28737 
 
28738 
  def __eq__(self, other):
28739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28740 
 
28741 
  def __ne__(self, other):
28742 
    return not (self == other)
28743 
 
6031 rajveer 28744 
class getUserWallet_args:
6000 mandeep.dh 28745 
  """
28746 
  Attributes:
6031 rajveer 28747 
   - userId
6000 mandeep.dh 28748 
  """
28749 
 
28750 
  thrift_spec = (
28751 
    None, # 0
6031 rajveer 28752 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28753 
  )
28754 
 
6031 rajveer 28755 
  def __init__(self, userId=None,):
28756 
    self.userId = userId
6000 mandeep.dh 28757 
 
28758 
  def read(self, iprot):
28759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28761 
      return
28762 
    iprot.readStructBegin()
28763 
    while True:
28764 
      (fname, ftype, fid) = iprot.readFieldBegin()
28765 
      if ftype == TType.STOP:
28766 
        break
28767 
      if fid == 1:
28768 
        if ftype == TType.I64:
6031 rajveer 28769 
          self.userId = iprot.readI64();
6000 mandeep.dh 28770 
        else:
28771 
          iprot.skip(ftype)
28772 
      else:
28773 
        iprot.skip(ftype)
28774 
      iprot.readFieldEnd()
28775 
    iprot.readStructEnd()
28776 
 
28777 
  def write(self, oprot):
28778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28780 
      return
6031 rajveer 28781 
    oprot.writeStructBegin('getUserWallet_args')
28782 
    if self.userId is not None:
28783 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28784 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28785 
      oprot.writeFieldEnd()
28786 
    oprot.writeFieldStop()
28787 
    oprot.writeStructEnd()
28788 
 
28789 
  def validate(self):
28790 
    return
28791 
 
28792 
 
28793 
  def __repr__(self):
28794 
    L = ['%s=%r' % (key, value)
28795 
      for key, value in self.__dict__.iteritems()]
28796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28797 
 
28798 
  def __eq__(self, other):
28799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28800 
 
28801 
  def __ne__(self, other):
28802 
    return not (self == other)
28803 
 
6031 rajveer 28804 
class getUserWallet_result:
6000 mandeep.dh 28805 
  """
28806 
  Attributes:
28807 
   - success
28808 
  """
28809 
 
28810 
  thrift_spec = (
6031 rajveer 28811 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28812 
  )
28813 
 
28814 
  def __init__(self, success=None,):
28815 
    self.success = success
28816 
 
28817 
  def read(self, iprot):
28818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28820 
      return
28821 
    iprot.readStructBegin()
28822 
    while True:
28823 
      (fname, ftype, fid) = iprot.readFieldBegin()
28824 
      if ftype == TType.STOP:
28825 
        break
28826 
      if fid == 0:
6031 rajveer 28827 
        if ftype == TType.STRUCT:
28828 
          self.success = UserWallet()
28829 
          self.success.read(iprot)
6000 mandeep.dh 28830 
        else:
28831 
          iprot.skip(ftype)
28832 
      else:
28833 
        iprot.skip(ftype)
28834 
      iprot.readFieldEnd()
28835 
    iprot.readStructEnd()
28836 
 
28837 
  def write(self, oprot):
28838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28840 
      return
6031 rajveer 28841 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28842 
    if self.success is not None:
6031 rajveer 28843 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28844 
      self.success.write(oprot)
6000 mandeep.dh 28845 
      oprot.writeFieldEnd()
28846 
    oprot.writeFieldStop()
28847 
    oprot.writeStructEnd()
28848 
 
28849 
  def validate(self):
28850 
    return
28851 
 
28852 
 
28853 
  def __repr__(self):
28854 
    L = ['%s=%r' % (key, value)
28855 
      for key, value in self.__dict__.iteritems()]
28856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28857 
 
28858 
  def __eq__(self, other):
28859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28860 
 
28861 
  def __ne__(self, other):
28862 
    return not (self == other)
28863 
 
6031 rajveer 28864 
class getUserWalletHistory_args:
6000 mandeep.dh 28865 
  """
28866 
  Attributes:
6031 rajveer 28867 
   - userId
6000 mandeep.dh 28868 
  """
28869 
 
28870 
  thrift_spec = (
28871 
    None, # 0
6031 rajveer 28872 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28873 
  )
28874 
 
6031 rajveer 28875 
  def __init__(self, userId=None,):
28876 
    self.userId = userId
6000 mandeep.dh 28877 
 
28878 
  def read(self, iprot):
28879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28881 
      return
28882 
    iprot.readStructBegin()
28883 
    while True:
28884 
      (fname, ftype, fid) = iprot.readFieldBegin()
28885 
      if ftype == TType.STOP:
28886 
        break
28887 
      if fid == 1:
28888 
        if ftype == TType.I64:
6031 rajveer 28889 
          self.userId = iprot.readI64();
6000 mandeep.dh 28890 
        else:
28891 
          iprot.skip(ftype)
28892 
      else:
28893 
        iprot.skip(ftype)
28894 
      iprot.readFieldEnd()
28895 
    iprot.readStructEnd()
28896 
 
28897 
  def write(self, oprot):
28898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28900 
      return
6031 rajveer 28901 
    oprot.writeStructBegin('getUserWalletHistory_args')
28902 
    if self.userId is not None:
28903 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28904 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28905 
      oprot.writeFieldEnd()
28906 
    oprot.writeFieldStop()
28907 
    oprot.writeStructEnd()
28908 
 
28909 
  def validate(self):
28910 
    return
28911 
 
28912 
 
28913 
  def __repr__(self):
28914 
    L = ['%s=%r' % (key, value)
28915 
      for key, value in self.__dict__.iteritems()]
28916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28917 
 
28918 
  def __eq__(self, other):
28919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28920 
 
28921 
  def __ne__(self, other):
28922 
    return not (self == other)
28923 
 
6031 rajveer 28924 
class getUserWalletHistory_result:
6000 mandeep.dh 28925 
  """
28926 
  Attributes:
28927 
   - success
28928 
  """
28929 
 
28930 
  thrift_spec = (
6031 rajveer 28931 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28932 
  )
28933 
 
28934 
  def __init__(self, success=None,):
28935 
    self.success = success
28936 
 
28937 
  def read(self, iprot):
28938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28940 
      return
28941 
    iprot.readStructBegin()
28942 
    while True:
28943 
      (fname, ftype, fid) = iprot.readFieldBegin()
28944 
      if ftype == TType.STOP:
28945 
        break
28946 
      if fid == 0:
28947 
        if ftype == TType.LIST:
28948 
          self.success = []
6188 rajveer 28949 
          (_etype666, _size663) = iprot.readListBegin()
28950 
          for _i667 in xrange(_size663):
28951 
            _elem668 = UserWalletHistory()
28952 
            _elem668.read(iprot)
28953 
            self.success.append(_elem668)
6000 mandeep.dh 28954 
          iprot.readListEnd()
28955 
        else:
28956 
          iprot.skip(ftype)
28957 
      else:
28958 
        iprot.skip(ftype)
28959 
      iprot.readFieldEnd()
28960 
    iprot.readStructEnd()
28961 
 
28962 
  def write(self, oprot):
28963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28965 
      return
6031 rajveer 28966 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28967 
    if self.success is not None:
28968 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28969 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28970 
      for iter669 in self.success:
28971 
        iter669.write(oprot)
6000 mandeep.dh 28972 
      oprot.writeListEnd()
28973 
      oprot.writeFieldEnd()
28974 
    oprot.writeFieldStop()
28975 
    oprot.writeStructEnd()
28976 
 
28977 
  def validate(self):
28978 
    return
28979 
 
28980 
 
28981 
  def __repr__(self):
28982 
    L = ['%s=%r' % (key, value)
28983 
      for key, value in self.__dict__.iteritems()]
28984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28985 
 
28986 
  def __eq__(self, other):
28987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28988 
 
28989 
  def __ne__(self, other):
28990 
    return not (self == other)
6048 rajveer 28991 
 
6050 anupam.sin 28992 
class getRechargeOrdersForTransaction_args:
28993 
  """
28994 
  Attributes:
28995 
   - txnId
28996 
  """
28997 
 
28998 
  thrift_spec = (
28999 
    None, # 0
29000 
    (1, TType.I64, 'txnId', None, None, ), # 1
29001 
  )
29002 
 
29003 
  def __init__(self, txnId=None,):
29004 
    self.txnId = txnId
29005 
 
29006 
  def read(self, iprot):
29007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29009 
      return
29010 
    iprot.readStructBegin()
29011 
    while True:
29012 
      (fname, ftype, fid) = iprot.readFieldBegin()
29013 
      if ftype == TType.STOP:
29014 
        break
29015 
      if fid == 1:
29016 
        if ftype == TType.I64:
29017 
          self.txnId = iprot.readI64();
29018 
        else:
29019 
          iprot.skip(ftype)
29020 
      else:
29021 
        iprot.skip(ftype)
29022 
      iprot.readFieldEnd()
29023 
    iprot.readStructEnd()
29024 
 
29025 
  def write(self, oprot):
29026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29028 
      return
29029 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
29030 
    if self.txnId is not None:
29031 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
29032 
      oprot.writeI64(self.txnId)
29033 
      oprot.writeFieldEnd()
29034 
    oprot.writeFieldStop()
29035 
    oprot.writeStructEnd()
29036 
 
29037 
  def validate(self):
29038 
    return
29039 
 
29040 
 
29041 
  def __repr__(self):
29042 
    L = ['%s=%r' % (key, value)
29043 
      for key, value in self.__dict__.iteritems()]
29044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29045 
 
29046 
  def __eq__(self, other):
29047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29048 
 
29049 
  def __ne__(self, other):
29050 
    return not (self == other)
29051 
 
29052 
class getRechargeOrdersForTransaction_result:
29053 
  """
29054 
  Attributes:
29055 
   - success
29056 
   - ex
29057 
  """
29058 
 
29059 
  thrift_spec = (
29060 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
29061 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29062 
  )
29063 
 
29064 
  def __init__(self, success=None, ex=None,):
29065 
    self.success = success
29066 
    self.ex = ex
29067 
 
29068 
  def read(self, iprot):
29069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29071 
      return
29072 
    iprot.readStructBegin()
29073 
    while True:
29074 
      (fname, ftype, fid) = iprot.readFieldBegin()
29075 
      if ftype == TType.STOP:
29076 
        break
29077 
      if fid == 0:
29078 
        if ftype == TType.STRUCT:
29079 
          self.success = RechargeOrder()
29080 
          self.success.read(iprot)
29081 
        else:
29082 
          iprot.skip(ftype)
29083 
      elif fid == 1:
29084 
        if ftype == TType.STRUCT:
29085 
          self.ex = TransactionServiceException()
29086 
          self.ex.read(iprot)
29087 
        else:
29088 
          iprot.skip(ftype)
29089 
      else:
29090 
        iprot.skip(ftype)
29091 
      iprot.readFieldEnd()
29092 
    iprot.readStructEnd()
29093 
 
29094 
  def write(self, oprot):
29095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29097 
      return
29098 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
29099 
    if self.success is not None:
29100 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29101 
      self.success.write(oprot)
29102 
      oprot.writeFieldEnd()
29103 
    if self.ex is not None:
29104 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29105 
      self.ex.write(oprot)
29106 
      oprot.writeFieldEnd()
29107 
    oprot.writeFieldStop()
29108 
    oprot.writeStructEnd()
29109 
 
29110 
  def validate(self):
29111 
    return
29112 
 
29113 
 
29114 
  def __repr__(self):
29115 
    L = ['%s=%r' % (key, value)
29116 
      for key, value in self.__dict__.iteritems()]
29117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29118 
 
29119 
  def __eq__(self, other):
29120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29121 
 
29122 
  def __ne__(self, other):
29123 
    return not (self == other)
29124 
 
6048 rajveer 29125 
class getServiceProviders_args:
29126 
  """
29127 
  Attributes:
29128 
   - rechargeType
6206 rajveer 29129 
   - onlyActive
6048 rajveer 29130 
  """
29131 
 
29132 
  thrift_spec = (
29133 
    None, # 0
29134 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 29135 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 29136 
  )
29137 
 
6206 rajveer 29138 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 29139 
    self.rechargeType = rechargeType
6206 rajveer 29140 
    self.onlyActive = onlyActive
6048 rajveer 29141 
 
29142 
  def read(self, iprot):
29143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29145 
      return
29146 
    iprot.readStructBegin()
29147 
    while True:
29148 
      (fname, ftype, fid) = iprot.readFieldBegin()
29149 
      if ftype == TType.STOP:
29150 
        break
29151 
      if fid == 1:
29152 
        if ftype == TType.I32:
29153 
          self.rechargeType = iprot.readI32();
29154 
        else:
29155 
          iprot.skip(ftype)
6206 rajveer 29156 
      elif fid == 2:
29157 
        if ftype == TType.BOOL:
29158 
          self.onlyActive = iprot.readBool();
29159 
        else:
29160 
          iprot.skip(ftype)
6048 rajveer 29161 
      else:
29162 
        iprot.skip(ftype)
29163 
      iprot.readFieldEnd()
29164 
    iprot.readStructEnd()
29165 
 
29166 
  def write(self, oprot):
29167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29169 
      return
29170 
    oprot.writeStructBegin('getServiceProviders_args')
29171 
    if self.rechargeType is not None:
29172 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29173 
      oprot.writeI32(self.rechargeType)
29174 
      oprot.writeFieldEnd()
6206 rajveer 29175 
    if self.onlyActive is not None:
29176 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
29177 
      oprot.writeBool(self.onlyActive)
29178 
      oprot.writeFieldEnd()
6048 rajveer 29179 
    oprot.writeFieldStop()
29180 
    oprot.writeStructEnd()
29181 
 
29182 
  def validate(self):
29183 
    return
29184 
 
29185 
 
29186 
  def __repr__(self):
29187 
    L = ['%s=%r' % (key, value)
29188 
      for key, value in self.__dict__.iteritems()]
29189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29190 
 
29191 
  def __eq__(self, other):
29192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29193 
 
29194 
  def __ne__(self, other):
29195 
    return not (self == other)
29196 
 
29197 
class getServiceProviders_result:
29198 
  """
29199 
  Attributes:
29200 
   - success
29201 
  """
29202 
 
29203 
  thrift_spec = (
29204 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
29205 
  )
29206 
 
29207 
  def __init__(self, success=None,):
29208 
    self.success = success
29209 
 
29210 
  def read(self, iprot):
29211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29213 
      return
29214 
    iprot.readStructBegin()
29215 
    while True:
29216 
      (fname, ftype, fid) = iprot.readFieldBegin()
29217 
      if ftype == TType.STOP:
29218 
        break
29219 
      if fid == 0:
29220 
        if ftype == TType.MAP:
29221 
          self.success = {}
6188 rajveer 29222 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
29223 
          for _i674 in xrange(_size670):
29224 
            _key675 = iprot.readI64();
29225 
            _val676 = iprot.readString();
29226 
            self.success[_key675] = _val676
6048 rajveer 29227 
          iprot.readMapEnd()
29228 
        else:
29229 
          iprot.skip(ftype)
29230 
      else:
29231 
        iprot.skip(ftype)
29232 
      iprot.readFieldEnd()
29233 
    iprot.readStructEnd()
29234 
 
29235 
  def write(self, oprot):
29236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29238 
      return
29239 
    oprot.writeStructBegin('getServiceProviders_result')
29240 
    if self.success is not None:
29241 
      oprot.writeFieldBegin('success', TType.MAP, 0)
29242 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 29243 
      for kiter677,viter678 in self.success.items():
29244 
        oprot.writeI64(kiter677)
29245 
        oprot.writeString(viter678)
6048 rajveer 29246 
      oprot.writeMapEnd()
29247 
      oprot.writeFieldEnd()
29248 
    oprot.writeFieldStop()
29249 
    oprot.writeStructEnd()
29250 
 
29251 
  def validate(self):
29252 
    return
29253 
 
29254 
 
29255 
  def __repr__(self):
29256 
    L = ['%s=%r' % (key, value)
29257 
      for key, value in self.__dict__.iteritems()]
29258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29259 
 
29260 
  def __eq__(self, other):
29261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29262 
 
29263 
  def __ne__(self, other):
29264 
    return not (self == other)
29265 
 
29266 
class getServiceProviderForDevice_args:
29267 
  """
29268 
  Attributes:
6049 rajveer 29269 
   - rechargeType
6048 rajveer 29270 
   - deviceNumber
29271 
  """
29272 
 
29273 
  thrift_spec = (
29274 
    None, # 0
6049 rajveer 29275 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
29276 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 29277 
  )
29278 
 
6049 rajveer 29279 
  def __init__(self, rechargeType=None, deviceNumber=None,):
29280 
    self.rechargeType = rechargeType
6048 rajveer 29281 
    self.deviceNumber = deviceNumber
29282 
 
29283 
  def read(self, iprot):
29284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29286 
      return
29287 
    iprot.readStructBegin()
29288 
    while True:
29289 
      (fname, ftype, fid) = iprot.readFieldBegin()
29290 
      if ftype == TType.STOP:
29291 
        break
29292 
      if fid == 1:
6049 rajveer 29293 
        if ftype == TType.I32:
29294 
          self.rechargeType = iprot.readI32();
29295 
        else:
29296 
          iprot.skip(ftype)
29297 
      elif fid == 2:
6048 rajveer 29298 
        if ftype == TType.STRING:
29299 
          self.deviceNumber = iprot.readString();
29300 
        else:
29301 
          iprot.skip(ftype)
29302 
      else:
29303 
        iprot.skip(ftype)
29304 
      iprot.readFieldEnd()
29305 
    iprot.readStructEnd()
29306 
 
29307 
  def write(self, oprot):
29308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29310 
      return
29311 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 29312 
    if self.rechargeType is not None:
29313 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29314 
      oprot.writeI32(self.rechargeType)
29315 
      oprot.writeFieldEnd()
6048 rajveer 29316 
    if self.deviceNumber is not None:
6049 rajveer 29317 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 29318 
      oprot.writeString(self.deviceNumber)
29319 
      oprot.writeFieldEnd()
29320 
    oprot.writeFieldStop()
29321 
    oprot.writeStructEnd()
29322 
 
29323 
  def validate(self):
29324 
    return
29325 
 
29326 
 
29327 
  def __repr__(self):
29328 
    L = ['%s=%r' % (key, value)
29329 
      for key, value in self.__dict__.iteritems()]
29330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29331 
 
29332 
  def __eq__(self, other):
29333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29334 
 
29335 
  def __ne__(self, other):
29336 
    return not (self == other)
29337 
 
29338 
class getServiceProviderForDevice_result:
29339 
  """
29340 
  Attributes:
29341 
   - success
29342 
  """
29343 
 
29344 
  thrift_spec = (
6289 anupam.sin 29345 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 29346 
  )
29347 
 
29348 
  def __init__(self, success=None,):
29349 
    self.success = success
29350 
 
29351 
  def read(self, iprot):
29352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29354 
      return
29355 
    iprot.readStructBegin()
29356 
    while True:
29357 
      (fname, ftype, fid) = iprot.readFieldBegin()
29358 
      if ftype == TType.STOP:
29359 
        break
29360 
      if fid == 0:
6289 anupam.sin 29361 
        if ftype == TType.STRUCT:
29362 
          self.success = DeviceNumberInfo()
29363 
          self.success.read(iprot)
6048 rajveer 29364 
        else:
29365 
          iprot.skip(ftype)
29366 
      else:
29367 
        iprot.skip(ftype)
29368 
      iprot.readFieldEnd()
29369 
    iprot.readStructEnd()
29370 
 
29371 
  def write(self, oprot):
29372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29374 
      return
29375 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
29376 
    if self.success is not None:
6289 anupam.sin 29377 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29378 
      self.success.write(oprot)
6048 rajveer 29379 
      oprot.writeFieldEnd()
29380 
    oprot.writeFieldStop()
29381 
    oprot.writeStructEnd()
29382 
 
29383 
  def validate(self):
29384 
    return
29385 
 
29386 
 
29387 
  def __repr__(self):
29388 
    L = ['%s=%r' % (key, value)
29389 
      for key, value in self.__dict__.iteritems()]
29390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29391 
 
29392 
  def __eq__(self, other):
29393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29394 
 
29395 
  def __ne__(self, other):
29396 
    return not (self == other)
6094 rajveer 29397 
 
6269 rajveer 29398 
class validateRecharge_args:
29399 
  """
29400 
  Attributes:
29401 
   - rechargeType
29402 
   - deviceNumber
6307 anupam.sin 29403 
   - userSelectedProviderId
6591 anupam.sin 29404 
   - clientAddress
6269 rajveer 29405 
  """
29406 
 
29407 
  thrift_spec = (
29408 
    None, # 0
29409 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
29410 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 29411 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 29412 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 29413 
  )
29414 
 
6591 anupam.sin 29415 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 29416 
    self.rechargeType = rechargeType
29417 
    self.deviceNumber = deviceNumber
6307 anupam.sin 29418 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 29419 
    self.clientAddress = clientAddress
6269 rajveer 29420 
 
29421 
  def read(self, iprot):
29422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29424 
      return
29425 
    iprot.readStructBegin()
29426 
    while True:
29427 
      (fname, ftype, fid) = iprot.readFieldBegin()
29428 
      if ftype == TType.STOP:
29429 
        break
29430 
      if fid == 1:
29431 
        if ftype == TType.I32:
29432 
          self.rechargeType = iprot.readI32();
29433 
        else:
29434 
          iprot.skip(ftype)
29435 
      elif fid == 2:
29436 
        if ftype == TType.STRING:
29437 
          self.deviceNumber = iprot.readString();
29438 
        else:
29439 
          iprot.skip(ftype)
6307 anupam.sin 29440 
      elif fid == 3:
29441 
        if ftype == TType.I64:
29442 
          self.userSelectedProviderId = iprot.readI64();
29443 
        else:
29444 
          iprot.skip(ftype)
6591 anupam.sin 29445 
      elif fid == 4:
29446 
        if ftype == TType.STRING:
29447 
          self.clientAddress = iprot.readString();
29448 
        else:
29449 
          iprot.skip(ftype)
6269 rajveer 29450 
      else:
29451 
        iprot.skip(ftype)
29452 
      iprot.readFieldEnd()
29453 
    iprot.readStructEnd()
29454 
 
29455 
  def write(self, oprot):
29456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29458 
      return
29459 
    oprot.writeStructBegin('validateRecharge_args')
29460 
    if self.rechargeType is not None:
29461 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29462 
      oprot.writeI32(self.rechargeType)
29463 
      oprot.writeFieldEnd()
29464 
    if self.deviceNumber is not None:
29465 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
29466 
      oprot.writeString(self.deviceNumber)
29467 
      oprot.writeFieldEnd()
6307 anupam.sin 29468 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 29469 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 29470 
      oprot.writeI64(self.userSelectedProviderId)
29471 
      oprot.writeFieldEnd()
6591 anupam.sin 29472 
    if self.clientAddress is not None:
29473 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
29474 
      oprot.writeString(self.clientAddress)
29475 
      oprot.writeFieldEnd()
6269 rajveer 29476 
    oprot.writeFieldStop()
29477 
    oprot.writeStructEnd()
29478 
 
29479 
  def validate(self):
29480 
    return
29481 
 
29482 
 
29483 
  def __repr__(self):
29484 
    L = ['%s=%r' % (key, value)
29485 
      for key, value in self.__dict__.iteritems()]
29486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29487 
 
29488 
  def __eq__(self, other):
29489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29490 
 
29491 
  def __ne__(self, other):
29492 
    return not (self == other)
29493 
 
29494 
class validateRecharge_result:
29495 
  """
29496 
  Attributes:
29497 
   - success
29498 
  """
29499 
 
29500 
  thrift_spec = (
29501 
    (0, TType.STRING, 'success', None, None, ), # 0
29502 
  )
29503 
 
29504 
  def __init__(self, success=None,):
29505 
    self.success = success
29506 
 
29507 
  def read(self, iprot):
29508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29510 
      return
29511 
    iprot.readStructBegin()
29512 
    while True:
29513 
      (fname, ftype, fid) = iprot.readFieldBegin()
29514 
      if ftype == TType.STOP:
29515 
        break
29516 
      if fid == 0:
29517 
        if ftype == TType.STRING:
29518 
          self.success = iprot.readString();
29519 
        else:
29520 
          iprot.skip(ftype)
29521 
      else:
29522 
        iprot.skip(ftype)
29523 
      iprot.readFieldEnd()
29524 
    iprot.readStructEnd()
29525 
 
29526 
  def write(self, oprot):
29527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29529 
      return
29530 
    oprot.writeStructBegin('validateRecharge_result')
29531 
    if self.success is not None:
29532 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29533 
      oprot.writeString(self.success)
29534 
      oprot.writeFieldEnd()
29535 
    oprot.writeFieldStop()
29536 
    oprot.writeStructEnd()
29537 
 
29538 
  def validate(self):
29539 
    return
29540 
 
29541 
 
29542 
  def __repr__(self):
29543 
    L = ['%s=%r' % (key, value)
29544 
      for key, value in self.__dict__.iteritems()]
29545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29546 
 
29547 
  def __eq__(self, other):
29548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29549 
 
29550 
  def __ne__(self, other):
29551 
    return not (self == other)
29552 
 
6094 rajveer 29553 
class getRechargeOrdersForDevice_args:
29554 
  """
29555 
  Attributes:
29556 
   - deviceNumber
29557 
  """
29558 
 
29559 
  thrift_spec = (
29560 
    None, # 0
29561 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
29562 
  )
29563 
 
29564 
  def __init__(self, deviceNumber=None,):
29565 
    self.deviceNumber = deviceNumber
29566 
 
29567 
  def read(self, iprot):
29568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29570 
      return
29571 
    iprot.readStructBegin()
29572 
    while True:
29573 
      (fname, ftype, fid) = iprot.readFieldBegin()
29574 
      if ftype == TType.STOP:
29575 
        break
29576 
      if fid == 1:
29577 
        if ftype == TType.STRING:
29578 
          self.deviceNumber = iprot.readString();
29579 
        else:
29580 
          iprot.skip(ftype)
29581 
      else:
29582 
        iprot.skip(ftype)
29583 
      iprot.readFieldEnd()
29584 
    iprot.readStructEnd()
29585 
 
29586 
  def write(self, oprot):
29587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29589 
      return
29590 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
29591 
    if self.deviceNumber is not None:
29592 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
29593 
      oprot.writeString(self.deviceNumber)
29594 
      oprot.writeFieldEnd()
29595 
    oprot.writeFieldStop()
29596 
    oprot.writeStructEnd()
29597 
 
29598 
  def validate(self):
29599 
    return
29600 
 
29601 
 
29602 
  def __repr__(self):
29603 
    L = ['%s=%r' % (key, value)
29604 
      for key, value in self.__dict__.iteritems()]
29605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29606 
 
29607 
  def __eq__(self, other):
29608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29609 
 
29610 
  def __ne__(self, other):
29611 
    return not (self == other)
29612 
 
29613 
class getRechargeOrdersForDevice_result:
29614 
  """
29615 
  Attributes:
29616 
   - success
29617 
  """
29618 
 
29619 
  thrift_spec = (
29620 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29621 
  )
29622 
 
29623 
  def __init__(self, success=None,):
29624 
    self.success = success
29625 
 
29626 
  def read(self, iprot):
29627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29629 
      return
29630 
    iprot.readStructBegin()
29631 
    while True:
29632 
      (fname, ftype, fid) = iprot.readFieldBegin()
29633 
      if ftype == TType.STOP:
29634 
        break
29635 
      if fid == 0:
29636 
        if ftype == TType.LIST:
29637 
          self.success = []
6188 rajveer 29638 
          (_etype682, _size679) = iprot.readListBegin()
29639 
          for _i683 in xrange(_size679):
29640 
            _elem684 = RechargeOrder()
29641 
            _elem684.read(iprot)
29642 
            self.success.append(_elem684)
6094 rajveer 29643 
          iprot.readListEnd()
29644 
        else:
29645 
          iprot.skip(ftype)
29646 
      else:
29647 
        iprot.skip(ftype)
29648 
      iprot.readFieldEnd()
29649 
    iprot.readStructEnd()
29650 
 
29651 
  def write(self, oprot):
29652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29654 
      return
29655 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
29656 
    if self.success is not None:
29657 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29658 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29659 
      for iter685 in self.success:
29660 
        iter685.write(oprot)
6094 rajveer 29661 
      oprot.writeListEnd()
29662 
      oprot.writeFieldEnd()
29663 
    oprot.writeFieldStop()
29664 
    oprot.writeStructEnd()
29665 
 
29666 
  def validate(self):
29667 
    return
29668 
 
29669 
 
29670 
  def __repr__(self):
29671 
    L = ['%s=%r' % (key, value)
29672 
      for key, value in self.__dict__.iteritems()]
29673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29674 
 
29675 
  def __eq__(self, other):
29676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29677 
 
29678 
  def __ne__(self, other):
29679 
    return not (self == other)
29680 
 
29681 
class addAmountToWallet_args:
29682 
  """
29683 
  Attributes:
29684 
   - userId
29685 
   - orderId
29686 
   - amount
29687 
  """
29688 
 
29689 
  thrift_spec = (
29690 
    None, # 0
29691 
    (1, TType.I64, 'userId', None, None, ), # 1
29692 
    (2, TType.I64, 'orderId', None, None, ), # 2
29693 
    (3, TType.I64, 'amount', None, None, ), # 3
29694 
  )
29695 
 
29696 
  def __init__(self, userId=None, orderId=None, amount=None,):
29697 
    self.userId = userId
29698 
    self.orderId = orderId
29699 
    self.amount = amount
29700 
 
29701 
  def read(self, iprot):
29702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29704 
      return
29705 
    iprot.readStructBegin()
29706 
    while True:
29707 
      (fname, ftype, fid) = iprot.readFieldBegin()
29708 
      if ftype == TType.STOP:
29709 
        break
29710 
      if fid == 1:
29711 
        if ftype == TType.I64:
29712 
          self.userId = iprot.readI64();
29713 
        else:
29714 
          iprot.skip(ftype)
29715 
      elif fid == 2:
29716 
        if ftype == TType.I64:
29717 
          self.orderId = iprot.readI64();
29718 
        else:
29719 
          iprot.skip(ftype)
29720 
      elif fid == 3:
29721 
        if ftype == TType.I64:
29722 
          self.amount = iprot.readI64();
29723 
        else:
29724 
          iprot.skip(ftype)
29725 
      else:
29726 
        iprot.skip(ftype)
29727 
      iprot.readFieldEnd()
29728 
    iprot.readStructEnd()
29729 
 
29730 
  def write(self, oprot):
29731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29733 
      return
29734 
    oprot.writeStructBegin('addAmountToWallet_args')
29735 
    if self.userId is not None:
29736 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29737 
      oprot.writeI64(self.userId)
29738 
      oprot.writeFieldEnd()
29739 
    if self.orderId is not None:
29740 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29741 
      oprot.writeI64(self.orderId)
29742 
      oprot.writeFieldEnd()
29743 
    if self.amount is not None:
29744 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29745 
      oprot.writeI64(self.amount)
29746 
      oprot.writeFieldEnd()
29747 
    oprot.writeFieldStop()
29748 
    oprot.writeStructEnd()
29749 
 
29750 
  def validate(self):
29751 
    return
29752 
 
29753 
 
29754 
  def __repr__(self):
29755 
    L = ['%s=%r' % (key, value)
29756 
      for key, value in self.__dict__.iteritems()]
29757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29758 
 
29759 
  def __eq__(self, other):
29760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29761 
 
29762 
  def __ne__(self, other):
29763 
    return not (self == other)
29764 
 
29765 
class addAmountToWallet_result:
29766 
 
29767 
  thrift_spec = (
29768 
  )
29769 
 
29770 
  def read(self, iprot):
29771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29773 
      return
29774 
    iprot.readStructBegin()
29775 
    while True:
29776 
      (fname, ftype, fid) = iprot.readFieldBegin()
29777 
      if ftype == TType.STOP:
29778 
        break
29779 
      else:
29780 
        iprot.skip(ftype)
29781 
      iprot.readFieldEnd()
29782 
    iprot.readStructEnd()
29783 
 
29784 
  def write(self, oprot):
29785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29787 
      return
29788 
    oprot.writeStructBegin('addAmountToWallet_result')
29789 
    oprot.writeFieldStop()
29790 
    oprot.writeStructEnd()
29791 
 
29792 
  def validate(self):
29793 
    return
29794 
 
29795 
 
29796 
  def __repr__(self):
29797 
    L = ['%s=%r' % (key, value)
29798 
      for key, value in self.__dict__.iteritems()]
29799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29800 
 
29801 
  def __eq__(self, other):
29802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29803 
 
29804 
  def __ne__(self, other):
29805 
    return not (self == other)
6154 rajveer 29806 
 
6188 rajveer 29807 
class getRechargeStatistics_args:
29808 
 
29809 
  thrift_spec = (
29810 
  )
29811 
 
29812 
  def read(self, iprot):
29813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29815 
      return
29816 
    iprot.readStructBegin()
29817 
    while True:
29818 
      (fname, ftype, fid) = iprot.readFieldBegin()
29819 
      if ftype == TType.STOP:
29820 
        break
29821 
      else:
29822 
        iprot.skip(ftype)
29823 
      iprot.readFieldEnd()
29824 
    iprot.readStructEnd()
29825 
 
29826 
  def write(self, oprot):
29827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29829 
      return
29830 
    oprot.writeStructBegin('getRechargeStatistics_args')
29831 
    oprot.writeFieldStop()
29832 
    oprot.writeStructEnd()
29833 
 
29834 
  def validate(self):
29835 
    return
29836 
 
29837 
 
29838 
  def __repr__(self):
29839 
    L = ['%s=%r' % (key, value)
29840 
      for key, value in self.__dict__.iteritems()]
29841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29842 
 
29843 
  def __eq__(self, other):
29844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29845 
 
29846 
  def __ne__(self, other):
29847 
    return not (self == other)
29848 
 
29849 
class getRechargeStatistics_result:
29850 
  """
29851 
  Attributes:
29852 
   - success
29853 
  """
29854 
 
29855 
  thrift_spec = (
29856 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29857 
  )
29858 
 
29859 
  def __init__(self, success=None,):
29860 
    self.success = success
29861 
 
29862 
  def read(self, iprot):
29863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29865 
      return
29866 
    iprot.readStructBegin()
29867 
    while True:
29868 
      (fname, ftype, fid) = iprot.readFieldBegin()
29869 
      if ftype == TType.STOP:
29870 
        break
29871 
      if fid == 0:
29872 
        if ftype == TType.STRUCT:
29873 
          self.success = RechargeStatistics()
29874 
          self.success.read(iprot)
29875 
        else:
29876 
          iprot.skip(ftype)
29877 
      else:
29878 
        iprot.skip(ftype)
29879 
      iprot.readFieldEnd()
29880 
    iprot.readStructEnd()
29881 
 
29882 
  def write(self, oprot):
29883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29885 
      return
29886 
    oprot.writeStructBegin('getRechargeStatistics_result')
29887 
    if self.success is not None:
29888 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29889 
      self.success.write(oprot)
29890 
      oprot.writeFieldEnd()
29891 
    oprot.writeFieldStop()
29892 
    oprot.writeStructEnd()
29893 
 
29894 
  def validate(self):
29895 
    return
29896 
 
29897 
 
29898 
  def __repr__(self):
29899 
    L = ['%s=%r' % (key, value)
29900 
      for key, value in self.__dict__.iteritems()]
29901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29902 
 
29903 
  def __eq__(self, other):
29904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29905 
 
29906 
  def __ne__(self, other):
29907 
    return not (self == other)
29908 
 
6154 rajveer 29909 
class getRechargeOrdersForStatus_args:
29910 
  """
29911 
  Attributes:
29912 
   - status
29913 
  """
29914 
 
29915 
  thrift_spec = (
29916 
    None, # 0
29917 
    (1, TType.I64, 'status', None, None, ), # 1
29918 
  )
29919 
 
29920 
  def __init__(self, status=None,):
29921 
    self.status = status
29922 
 
29923 
  def read(self, iprot):
29924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29926 
      return
29927 
    iprot.readStructBegin()
29928 
    while True:
29929 
      (fname, ftype, fid) = iprot.readFieldBegin()
29930 
      if ftype == TType.STOP:
29931 
        break
29932 
      if fid == 1:
29933 
        if ftype == TType.I64:
29934 
          self.status = iprot.readI64();
29935 
        else:
29936 
          iprot.skip(ftype)
29937 
      else:
29938 
        iprot.skip(ftype)
29939 
      iprot.readFieldEnd()
29940 
    iprot.readStructEnd()
29941 
 
29942 
  def write(self, oprot):
29943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29945 
      return
29946 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29947 
    if self.status is not None:
29948 
      oprot.writeFieldBegin('status', TType.I64, 1)
29949 
      oprot.writeI64(self.status)
29950 
      oprot.writeFieldEnd()
29951 
    oprot.writeFieldStop()
29952 
    oprot.writeStructEnd()
29953 
 
29954 
  def validate(self):
29955 
    return
29956 
 
29957 
 
29958 
  def __repr__(self):
29959 
    L = ['%s=%r' % (key, value)
29960 
      for key, value in self.__dict__.iteritems()]
29961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29962 
 
29963 
  def __eq__(self, other):
29964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29965 
 
29966 
  def __ne__(self, other):
29967 
    return not (self == other)
29968 
 
29969 
class getRechargeOrdersForStatus_result:
29970 
  """
29971 
  Attributes:
29972 
   - success
29973 
  """
29974 
 
29975 
  thrift_spec = (
29976 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29977 
  )
29978 
 
29979 
  def __init__(self, success=None,):
29980 
    self.success = success
29981 
 
29982 
  def read(self, iprot):
29983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29985 
      return
29986 
    iprot.readStructBegin()
29987 
    while True:
29988 
      (fname, ftype, fid) = iprot.readFieldBegin()
29989 
      if ftype == TType.STOP:
29990 
        break
29991 
      if fid == 0:
29992 
        if ftype == TType.LIST:
29993 
          self.success = []
6188 rajveer 29994 
          (_etype689, _size686) = iprot.readListBegin()
29995 
          for _i690 in xrange(_size686):
29996 
            _elem691 = RechargeOrder()
29997 
            _elem691.read(iprot)
29998 
            self.success.append(_elem691)
6154 rajveer 29999 
          iprot.readListEnd()
30000 
        else:
30001 
          iprot.skip(ftype)
30002 
      else:
30003 
        iprot.skip(ftype)
30004 
      iprot.readFieldEnd()
30005 
    iprot.readStructEnd()
30006 
 
30007 
  def write(self, oprot):
30008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30010 
      return
30011 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
30012 
    if self.success is not None:
30013 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30014 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 30015 
      for iter692 in self.success:
30016 
        iter692.write(oprot)
6154 rajveer 30017 
      oprot.writeListEnd()
30018 
      oprot.writeFieldEnd()
30019 
    oprot.writeFieldStop()
30020 
    oprot.writeStructEnd()
30021 
 
30022 
  def validate(self):
30023 
    return
30024 
 
30025 
 
30026 
  def __repr__(self):
30027 
    L = ['%s=%r' % (key, value)
30028 
      for key, value in self.__dict__.iteritems()]
30029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30030 
 
30031 
  def __eq__(self, other):
30032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30033 
 
30034 
  def __ne__(self, other):
30035 
    return not (self == other)
6159 rajveer 30036 
 
30037 
class getPlansForOperator_args:
30038 
  """
30039 
  Attributes:
30040 
   - operatorId
30041 
  """
30042 
 
30043 
  thrift_spec = (
30044 
    None, # 0
30045 
    (1, TType.I64, 'operatorId', None, None, ), # 1
30046 
  )
30047 
 
30048 
  def __init__(self, operatorId=None,):
30049 
    self.operatorId = operatorId
30050 
 
30051 
  def read(self, iprot):
30052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30054 
      return
30055 
    iprot.readStructBegin()
30056 
    while True:
30057 
      (fname, ftype, fid) = iprot.readFieldBegin()
30058 
      if ftype == TType.STOP:
30059 
        break
30060 
      if fid == 1:
30061 
        if ftype == TType.I64:
30062 
          self.operatorId = iprot.readI64();
30063 
        else:
30064 
          iprot.skip(ftype)
30065 
      else:
30066 
        iprot.skip(ftype)
30067 
      iprot.readFieldEnd()
30068 
    iprot.readStructEnd()
30069 
 
30070 
  def write(self, oprot):
30071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30073 
      return
30074 
    oprot.writeStructBegin('getPlansForOperator_args')
30075 
    if self.operatorId is not None:
30076 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30077 
      oprot.writeI64(self.operatorId)
30078 
      oprot.writeFieldEnd()
30079 
    oprot.writeFieldStop()
30080 
    oprot.writeStructEnd()
30081 
 
30082 
  def validate(self):
30083 
    return
30084 
 
30085 
 
30086 
  def __repr__(self):
30087 
    L = ['%s=%r' % (key, value)
30088 
      for key, value in self.__dict__.iteritems()]
30089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30090 
 
30091 
  def __eq__(self, other):
30092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30093 
 
30094 
  def __ne__(self, other):
30095 
    return not (self == other)
30096 
 
30097 
class getPlansForOperator_result:
30098 
  """
30099 
  Attributes:
30100 
   - success
30101 
  """
30102 
 
30103 
  thrift_spec = (
30104 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
30105 
  )
30106 
 
30107 
  def __init__(self, success=None,):
30108 
    self.success = success
30109 
 
30110 
  def read(self, iprot):
30111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30113 
      return
30114 
    iprot.readStructBegin()
30115 
    while True:
30116 
      (fname, ftype, fid) = iprot.readFieldBegin()
30117 
      if ftype == TType.STOP:
30118 
        break
30119 
      if fid == 0:
30120 
        if ftype == TType.LIST:
30121 
          self.success = []
6188 rajveer 30122 
          (_etype696, _size693) = iprot.readListBegin()
30123 
          for _i697 in xrange(_size693):
30124 
            _elem698 = RechargePlan()
30125 
            _elem698.read(iprot)
30126 
            self.success.append(_elem698)
6159 rajveer 30127 
          iprot.readListEnd()
30128 
        else:
30129 
          iprot.skip(ftype)
30130 
      else:
30131 
        iprot.skip(ftype)
30132 
      iprot.readFieldEnd()
30133 
    iprot.readStructEnd()
30134 
 
30135 
  def write(self, oprot):
30136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30138 
      return
30139 
    oprot.writeStructBegin('getPlansForOperator_result')
30140 
    if self.success is not None:
30141 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30142 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 30143 
      for iter699 in self.success:
30144 
        iter699.write(oprot)
6159 rajveer 30145 
      oprot.writeListEnd()
30146 
      oprot.writeFieldEnd()
30147 
    oprot.writeFieldStop()
30148 
    oprot.writeStructEnd()
30149 
 
30150 
  def validate(self):
30151 
    return
30152 
 
30153 
 
30154 
  def __repr__(self):
30155 
    L = ['%s=%r' % (key, value)
30156 
      for key, value in self.__dict__.iteritems()]
30157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30158 
 
30159 
  def __eq__(self, other):
30160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30161 
 
30162 
  def __ne__(self, other):
30163 
    return not (self == other)
6289 anupam.sin 30164 
 
30165 
class getRechargeDenominations_args:
30166 
  """
30167 
  Attributes:
30168 
   - operatorId
6307 anupam.sin 30169 
   - circleCode
6289 anupam.sin 30170 
   - denominationType
30171 
  """
30172 
 
30173 
  thrift_spec = (
30174 
    None, # 0
30175 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 30176 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 30177 
    (3, TType.I32, 'denominationType', None, None, ), # 3
30178 
  )
30179 
 
6307 anupam.sin 30180 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 30181 
    self.operatorId = operatorId
6307 anupam.sin 30182 
    self.circleCode = circleCode
6289 anupam.sin 30183 
    self.denominationType = denominationType
30184 
 
30185 
  def read(self, iprot):
30186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30188 
      return
30189 
    iprot.readStructBegin()
30190 
    while True:
30191 
      (fname, ftype, fid) = iprot.readFieldBegin()
30192 
      if ftype == TType.STOP:
30193 
        break
30194 
      if fid == 1:
30195 
        if ftype == TType.I64:
30196 
          self.operatorId = iprot.readI64();
30197 
        else:
30198 
          iprot.skip(ftype)
30199 
      elif fid == 2:
30200 
        if ftype == TType.STRING:
6307 anupam.sin 30201 
          self.circleCode = iprot.readString();
6289 anupam.sin 30202 
        else:
30203 
          iprot.skip(ftype)
30204 
      elif fid == 3:
30205 
        if ftype == TType.I32:
30206 
          self.denominationType = iprot.readI32();
30207 
        else:
30208 
          iprot.skip(ftype)
30209 
      else:
30210 
        iprot.skip(ftype)
30211 
      iprot.readFieldEnd()
30212 
    iprot.readStructEnd()
30213 
 
30214 
  def write(self, oprot):
30215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30217 
      return
30218 
    oprot.writeStructBegin('getRechargeDenominations_args')
30219 
    if self.operatorId is not None:
30220 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30221 
      oprot.writeI64(self.operatorId)
30222 
      oprot.writeFieldEnd()
6307 anupam.sin 30223 
    if self.circleCode is not None:
30224 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
30225 
      oprot.writeString(self.circleCode)
6289 anupam.sin 30226 
      oprot.writeFieldEnd()
30227 
    if self.denominationType is not None:
30228 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
30229 
      oprot.writeI32(self.denominationType)
30230 
      oprot.writeFieldEnd()
30231 
    oprot.writeFieldStop()
30232 
    oprot.writeStructEnd()
30233 
 
30234 
  def validate(self):
30235 
    return
30236 
 
30237 
 
30238 
  def __repr__(self):
30239 
    L = ['%s=%r' % (key, value)
30240 
      for key, value in self.__dict__.iteritems()]
30241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30242 
 
30243 
  def __eq__(self, other):
30244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30245 
 
30246 
  def __ne__(self, other):
30247 
    return not (self == other)
30248 
 
30249 
class getRechargeDenominations_result:
30250 
  """
30251 
  Attributes:
30252 
   - success
30253 
   - ex
30254 
  """
30255 
 
30256 
  thrift_spec = (
30257 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
30258 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30259 
  )
30260 
 
30261 
  def __init__(self, success=None, ex=None,):
30262 
    self.success = success
30263 
    self.ex = ex
30264 
 
30265 
  def read(self, iprot):
30266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30268 
      return
30269 
    iprot.readStructBegin()
30270 
    while True:
30271 
      (fname, ftype, fid) = iprot.readFieldBegin()
30272 
      if ftype == TType.STOP:
30273 
        break
30274 
      if fid == 0:
30275 
        if ftype == TType.LIST:
30276 
          self.success = []
30277 
          (_etype703, _size700) = iprot.readListBegin()
30278 
          for _i704 in xrange(_size700):
30279 
            _elem705 = RechargeDenomination()
30280 
            _elem705.read(iprot)
30281 
            self.success.append(_elem705)
30282 
          iprot.readListEnd()
30283 
        else:
30284 
          iprot.skip(ftype)
30285 
      elif fid == 1:
30286 
        if ftype == TType.STRUCT:
30287 
          self.ex = TransactionServiceException()
30288 
          self.ex.read(iprot)
30289 
        else:
30290 
          iprot.skip(ftype)
30291 
      else:
30292 
        iprot.skip(ftype)
30293 
      iprot.readFieldEnd()
30294 
    iprot.readStructEnd()
30295 
 
30296 
  def write(self, oprot):
30297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30299 
      return
30300 
    oprot.writeStructBegin('getRechargeDenominations_result')
30301 
    if self.success is not None:
30302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30303 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30304 
      for iter706 in self.success:
30305 
        iter706.write(oprot)
30306 
      oprot.writeListEnd()
30307 
      oprot.writeFieldEnd()
30308 
    if self.ex is not None:
30309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30310 
      self.ex.write(oprot)
30311 
      oprot.writeFieldEnd()
30312 
    oprot.writeFieldStop()
30313 
    oprot.writeStructEnd()
30314 
 
30315 
  def validate(self):
30316 
    return
30317 
 
30318 
 
30319 
  def __repr__(self):
30320 
    L = ['%s=%r' % (key, value)
30321 
      for key, value in self.__dict__.iteritems()]
30322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30323 
 
30324 
  def __eq__(self, other):
30325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30326 
 
30327 
  def __ne__(self, other):
30328 
    return not (self == other)
6371 rajveer 30329 
 
30330 
class updateAvailabilityStatus_args:
30331 
  """
30332 
  Attributes:
30333 
   - operatorId
30334 
   - circleId
30335 
   - isAvailable
30336 
  """
30337 
 
30338 
  thrift_spec = (
30339 
    None, # 0
30340 
    (1, TType.I64, 'operatorId', None, None, ), # 1
30341 
    (2, TType.I64, 'circleId', None, None, ), # 2
30342 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
30343 
  )
30344 
 
30345 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
30346 
    self.operatorId = operatorId
30347 
    self.circleId = circleId
30348 
    self.isAvailable = isAvailable
30349 
 
30350 
  def read(self, iprot):
30351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30353 
      return
30354 
    iprot.readStructBegin()
30355 
    while True:
30356 
      (fname, ftype, fid) = iprot.readFieldBegin()
30357 
      if ftype == TType.STOP:
30358 
        break
30359 
      if fid == 1:
30360 
        if ftype == TType.I64:
30361 
          self.operatorId = iprot.readI64();
30362 
        else:
30363 
          iprot.skip(ftype)
30364 
      elif fid == 2:
30365 
        if ftype == TType.I64:
30366 
          self.circleId = iprot.readI64();
30367 
        else:
30368 
          iprot.skip(ftype)
30369 
      elif fid == 3:
30370 
        if ftype == TType.BOOL:
30371 
          self.isAvailable = iprot.readBool();
30372 
        else:
30373 
          iprot.skip(ftype)
30374 
      else:
30375 
        iprot.skip(ftype)
30376 
      iprot.readFieldEnd()
30377 
    iprot.readStructEnd()
30378 
 
30379 
  def write(self, oprot):
30380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30382 
      return
30383 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
30384 
    if self.operatorId is not None:
30385 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30386 
      oprot.writeI64(self.operatorId)
30387 
      oprot.writeFieldEnd()
30388 
    if self.circleId is not None:
30389 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
30390 
      oprot.writeI64(self.circleId)
30391 
      oprot.writeFieldEnd()
30392 
    if self.isAvailable is not None:
30393 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
30394 
      oprot.writeBool(self.isAvailable)
30395 
      oprot.writeFieldEnd()
30396 
    oprot.writeFieldStop()
30397 
    oprot.writeStructEnd()
30398 
 
30399 
  def validate(self):
30400 
    return
30401 
 
30402 
 
30403 
  def __repr__(self):
30404 
    L = ['%s=%r' % (key, value)
30405 
      for key, value in self.__dict__.iteritems()]
30406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30407 
 
30408 
  def __eq__(self, other):
30409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30410 
 
30411 
  def __ne__(self, other):
30412 
    return not (self == other)
30413 
 
30414 
class updateAvailabilityStatus_result:
30415 
 
30416 
  thrift_spec = (
30417 
  )
30418 
 
30419 
  def read(self, iprot):
30420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30422 
      return
30423 
    iprot.readStructBegin()
30424 
    while True:
30425 
      (fname, ftype, fid) = iprot.readFieldBegin()
30426 
      if ftype == TType.STOP:
30427 
        break
30428 
      else:
30429 
        iprot.skip(ftype)
30430 
      iprot.readFieldEnd()
30431 
    iprot.readStructEnd()
30432 
 
30433 
  def write(self, oprot):
30434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30436 
      return
30437 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
30438 
    oprot.writeFieldStop()
30439 
    oprot.writeStructEnd()
30440 
 
30441 
  def validate(self):
30442 
    return
30443 
 
30444 
 
30445 
  def __repr__(self):
30446 
    L = ['%s=%r' % (key, value)
30447 
      for key, value in self.__dict__.iteritems()]
30448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30449 
 
30450 
  def __eq__(self, other):
30451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30452 
 
30453 
  def __ne__(self, other):
30454 
    return not (self == other)
6389 rajveer 30455 
 
30456 
class getAvailableEmiSchemes_args:
30457 
 
30458 
  thrift_spec = (
30459 
  )
30460 
 
30461 
  def read(self, iprot):
30462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30464 
      return
30465 
    iprot.readStructBegin()
30466 
    while True:
30467 
      (fname, ftype, fid) = iprot.readFieldBegin()
30468 
      if ftype == TType.STOP:
30469 
        break
30470 
      else:
30471 
        iprot.skip(ftype)
30472 
      iprot.readFieldEnd()
30473 
    iprot.readStructEnd()
30474 
 
30475 
  def write(self, oprot):
30476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30478 
      return
30479 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
30480 
    oprot.writeFieldStop()
30481 
    oprot.writeStructEnd()
30482 
 
30483 
  def validate(self):
30484 
    return
30485 
 
30486 
 
30487 
  def __repr__(self):
30488 
    L = ['%s=%r' % (key, value)
30489 
      for key, value in self.__dict__.iteritems()]
30490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30491 
 
30492 
  def __eq__(self, other):
30493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30494 
 
30495 
  def __ne__(self, other):
30496 
    return not (self == other)
30497 
 
30498 
class getAvailableEmiSchemes_result:
30499 
  """
30500 
  Attributes:
30501 
   - success
30502 
  """
30503 
 
30504 
  thrift_spec = (
30505 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
30506 
  )
30507 
 
30508 
  def __init__(self, success=None,):
30509 
    self.success = success
30510 
 
30511 
  def read(self, iprot):
30512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30514 
      return
30515 
    iprot.readStructBegin()
30516 
    while True:
30517 
      (fname, ftype, fid) = iprot.readFieldBegin()
30518 
      if ftype == TType.STOP:
30519 
        break
30520 
      if fid == 0:
30521 
        if ftype == TType.LIST:
30522 
          self.success = []
30523 
          (_etype710, _size707) = iprot.readListBegin()
30524 
          for _i711 in xrange(_size707):
30525 
            _elem712 = EmiScheme()
30526 
            _elem712.read(iprot)
30527 
            self.success.append(_elem712)
30528 
          iprot.readListEnd()
30529 
        else:
30530 
          iprot.skip(ftype)
30531 
      else:
30532 
        iprot.skip(ftype)
30533 
      iprot.readFieldEnd()
30534 
    iprot.readStructEnd()
30535 
 
30536 
  def write(self, oprot):
30537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30539 
      return
30540 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
30541 
    if self.success is not None:
30542 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30543 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30544 
      for iter713 in self.success:
30545 
        iter713.write(oprot)
30546 
      oprot.writeListEnd()
30547 
      oprot.writeFieldEnd()
30548 
    oprot.writeFieldStop()
30549 
    oprot.writeStructEnd()
30550 
 
30551 
  def validate(self):
30552 
    return
30553 
 
30554 
 
30555 
  def __repr__(self):
30556 
    L = ['%s=%r' % (key, value)
30557 
      for key, value in self.__dict__.iteritems()]
30558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30559 
 
30560 
  def __eq__(self, other):
30561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30562 
 
30563 
  def __ne__(self, other):
30564 
    return not (self == other)
30565 
 
30566 
class getMiscCharges_args:
30567 
  """
30568 
  Attributes:
30569 
   - transactionId
30570 
  """
30571 
 
30572 
  thrift_spec = (
30573 
    None, # 0
30574 
    (1, TType.I64, 'transactionId', None, None, ), # 1
30575 
  )
30576 
 
30577 
  def __init__(self, transactionId=None,):
30578 
    self.transactionId = transactionId
30579 
 
30580 
  def read(self, iprot):
30581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30583 
      return
30584 
    iprot.readStructBegin()
30585 
    while True:
30586 
      (fname, ftype, fid) = iprot.readFieldBegin()
30587 
      if ftype == TType.STOP:
30588 
        break
30589 
      if fid == 1:
30590 
        if ftype == TType.I64:
30591 
          self.transactionId = iprot.readI64();
30592 
        else:
30593 
          iprot.skip(ftype)
30594 
      else:
30595 
        iprot.skip(ftype)
30596 
      iprot.readFieldEnd()
30597 
    iprot.readStructEnd()
30598 
 
30599 
  def write(self, oprot):
30600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30602 
      return
30603 
    oprot.writeStructBegin('getMiscCharges_args')
30604 
    if self.transactionId is not None:
30605 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
30606 
      oprot.writeI64(self.transactionId)
30607 
      oprot.writeFieldEnd()
30608 
    oprot.writeFieldStop()
30609 
    oprot.writeStructEnd()
30610 
 
30611 
  def validate(self):
30612 
    return
30613 
 
30614 
 
30615 
  def __repr__(self):
30616 
    L = ['%s=%r' % (key, value)
30617 
      for key, value in self.__dict__.iteritems()]
30618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30619 
 
30620 
  def __eq__(self, other):
30621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30622 
 
30623 
  def __ne__(self, other):
30624 
    return not (self == other)
30625 
 
30626 
class getMiscCharges_result:
30627 
  """
30628 
  Attributes:
30629 
   - success
30630 
  """
30631 
 
30632 
  thrift_spec = (
6412 rajveer 30633 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 30634 
  )
30635 
 
30636 
  def __init__(self, success=None,):
30637 
    self.success = success
30638 
 
30639 
  def read(self, iprot):
30640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30642 
      return
30643 
    iprot.readStructBegin()
30644 
    while True:
30645 
      (fname, ftype, fid) = iprot.readFieldBegin()
30646 
      if ftype == TType.STOP:
30647 
        break
30648 
      if fid == 0:
30649 
        if ftype == TType.MAP:
30650 
          self.success = {}
30651 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
30652 
          for _i718 in xrange(_size714):
30653 
            _key719 = iprot.readI64();
6412 rajveer 30654 
            _val720 = iprot.readDouble();
6389 rajveer 30655 
            self.success[_key719] = _val720
30656 
          iprot.readMapEnd()
30657 
        else:
30658 
          iprot.skip(ftype)
30659 
      else:
30660 
        iprot.skip(ftype)
30661 
      iprot.readFieldEnd()
30662 
    iprot.readStructEnd()
30663 
 
30664 
  def write(self, oprot):
30665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30667 
      return
30668 
    oprot.writeStructBegin('getMiscCharges_result')
30669 
    if self.success is not None:
30670 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 30671 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 30672 
      for kiter721,viter722 in self.success.items():
30673 
        oprot.writeI64(kiter721)
6412 rajveer 30674 
        oprot.writeDouble(viter722)
6389 rajveer 30675 
      oprot.writeMapEnd()
30676 
      oprot.writeFieldEnd()
30677 
    oprot.writeFieldStop()
30678 
    oprot.writeStructEnd()
30679 
 
30680 
  def validate(self):
30681 
    return
30682 
 
30683 
 
30684 
  def __repr__(self):
30685 
    L = ['%s=%r' % (key, value)
30686 
      for key, value in self.__dict__.iteritems()]
30687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30688 
 
30689 
  def __eq__(self, other):
30690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30691 
 
30692 
  def __ne__(self, other):
30693 
    return not (self == other)
6507 anupam.sin 30694 
 
30695 
class refundRechargeOrder_args:
30696 
  """
30697 
  Attributes:
30698 
   - rechargeOrderId
30699 
  """
30700 
 
30701 
  thrift_spec = (
30702 
    None, # 0
30703 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30704 
  )
30705 
 
30706 
  def __init__(self, rechargeOrderId=None,):
30707 
    self.rechargeOrderId = rechargeOrderId
30708 
 
30709 
  def read(self, iprot):
30710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30712 
      return
30713 
    iprot.readStructBegin()
30714 
    while True:
30715 
      (fname, ftype, fid) = iprot.readFieldBegin()
30716 
      if ftype == TType.STOP:
30717 
        break
30718 
      if fid == 1:
30719 
        if ftype == TType.I64:
30720 
          self.rechargeOrderId = iprot.readI64();
30721 
        else:
30722 
          iprot.skip(ftype)
30723 
      else:
30724 
        iprot.skip(ftype)
30725 
      iprot.readFieldEnd()
30726 
    iprot.readStructEnd()
30727 
 
30728 
  def write(self, oprot):
30729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30731 
      return
30732 
    oprot.writeStructBegin('refundRechargeOrder_args')
30733 
    if self.rechargeOrderId is not None:
30734 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30735 
      oprot.writeI64(self.rechargeOrderId)
30736 
      oprot.writeFieldEnd()
30737 
    oprot.writeFieldStop()
30738 
    oprot.writeStructEnd()
30739 
 
30740 
  def validate(self):
30741 
    return
30742 
 
30743 
 
30744 
  def __repr__(self):
30745 
    L = ['%s=%r' % (key, value)
30746 
      for key, value in self.__dict__.iteritems()]
30747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30748 
 
30749 
  def __eq__(self, other):
30750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30751 
 
30752 
  def __ne__(self, other):
30753 
    return not (self == other)
30754 
 
30755 
class refundRechargeOrder_result:
30756 
  """
30757 
  Attributes:
30758 
   - success
30759 
   - ex
30760 
  """
30761 
 
30762 
  thrift_spec = (
30763 
    (0, TType.BOOL, 'success', None, None, ), # 0
30764 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30765 
  )
30766 
 
30767 
  def __init__(self, success=None, ex=None,):
30768 
    self.success = success
30769 
    self.ex = ex
30770 
 
30771 
  def read(self, iprot):
30772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30774 
      return
30775 
    iprot.readStructBegin()
30776 
    while True:
30777 
      (fname, ftype, fid) = iprot.readFieldBegin()
30778 
      if ftype == TType.STOP:
30779 
        break
30780 
      if fid == 0:
30781 
        if ftype == TType.BOOL:
30782 
          self.success = iprot.readBool();
30783 
        else:
30784 
          iprot.skip(ftype)
30785 
      elif fid == 1:
30786 
        if ftype == TType.STRUCT:
30787 
          self.ex = TransactionServiceException()
30788 
          self.ex.read(iprot)
30789 
        else:
30790 
          iprot.skip(ftype)
30791 
      else:
30792 
        iprot.skip(ftype)
30793 
      iprot.readFieldEnd()
30794 
    iprot.readStructEnd()
30795 
 
30796 
  def write(self, oprot):
30797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30799 
      return
30800 
    oprot.writeStructBegin('refundRechargeOrder_result')
30801 
    if self.success is not None:
30802 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30803 
      oprot.writeBool(self.success)
30804 
      oprot.writeFieldEnd()
30805 
    if self.ex is not None:
30806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30807 
      self.ex.write(oprot)
30808 
      oprot.writeFieldEnd()
30809 
    oprot.writeFieldStop()
30810 
    oprot.writeStructEnd()
30811 
 
30812 
  def validate(self):
30813 
    return
30814 
 
30815 
 
30816 
  def __repr__(self):
30817 
    L = ['%s=%r' % (key, value)
30818 
      for key, value in self.__dict__.iteritems()]
30819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30820 
 
30821 
  def __eq__(self, other):
30822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30823 
 
30824 
  def __ne__(self, other):
30825 
    return not (self == other)
6821 amar.kumar 30826 
 
30827 
class getPhysicalOrders_args:
30828 
  """
30829 
  Attributes:
30830 
   - fromDate
30831 
   - toDate
30832 
  """
30833 
 
30834 
  thrift_spec = (
30835 
    None, # 0
30836 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30837 
    (2, TType.I64, 'toDate', None, None, ), # 2
30838 
  )
30839 
 
30840 
  def __init__(self, fromDate=None, toDate=None,):
30841 
    self.fromDate = fromDate
30842 
    self.toDate = toDate
30843 
 
30844 
  def read(self, iprot):
30845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30847 
      return
30848 
    iprot.readStructBegin()
30849 
    while True:
30850 
      (fname, ftype, fid) = iprot.readFieldBegin()
30851 
      if ftype == TType.STOP:
30852 
        break
30853 
      if fid == 1:
30854 
        if ftype == TType.I64:
30855 
          self.fromDate = iprot.readI64();
30856 
        else:
30857 
          iprot.skip(ftype)
30858 
      elif fid == 2:
30859 
        if ftype == TType.I64:
30860 
          self.toDate = iprot.readI64();
30861 
        else:
30862 
          iprot.skip(ftype)
30863 
      else:
30864 
        iprot.skip(ftype)
30865 
      iprot.readFieldEnd()
30866 
    iprot.readStructEnd()
30867 
 
30868 
  def write(self, oprot):
30869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30871 
      return
30872 
    oprot.writeStructBegin('getPhysicalOrders_args')
30873 
    if self.fromDate is not None:
30874 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30875 
      oprot.writeI64(self.fromDate)
30876 
      oprot.writeFieldEnd()
30877 
    if self.toDate is not None:
30878 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30879 
      oprot.writeI64(self.toDate)
30880 
      oprot.writeFieldEnd()
30881 
    oprot.writeFieldStop()
30882 
    oprot.writeStructEnd()
30883 
 
30884 
  def validate(self):
30885 
    return
30886 
 
30887 
 
30888 
  def __repr__(self):
30889 
    L = ['%s=%r' % (key, value)
30890 
      for key, value in self.__dict__.iteritems()]
30891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30892 
 
30893 
  def __eq__(self, other):
30894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30895 
 
30896 
  def __ne__(self, other):
30897 
    return not (self == other)
30898 
 
30899 
class getPhysicalOrders_result:
30900 
  """
30901 
  Attributes:
30902 
   - success
30903 
  """
30904 
 
30905 
  thrift_spec = (
30906 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30907 
  )
30908 
 
30909 
  def __init__(self, success=None,):
30910 
    self.success = success
30911 
 
30912 
  def read(self, iprot):
30913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30915 
      return
30916 
    iprot.readStructBegin()
30917 
    while True:
30918 
      (fname, ftype, fid) = iprot.readFieldBegin()
30919 
      if ftype == TType.STOP:
30920 
        break
30921 
      if fid == 0:
30922 
        if ftype == TType.LIST:
30923 
          self.success = []
30924 
          (_etype726, _size723) = iprot.readListBegin()
30925 
          for _i727 in xrange(_size723):
30926 
            _elem728 = Order()
30927 
            _elem728.read(iprot)
30928 
            self.success.append(_elem728)
30929 
          iprot.readListEnd()
30930 
        else:
30931 
          iprot.skip(ftype)
30932 
      else:
30933 
        iprot.skip(ftype)
30934 
      iprot.readFieldEnd()
30935 
    iprot.readStructEnd()
30936 
 
30937 
  def write(self, oprot):
30938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30940 
      return
30941 
    oprot.writeStructBegin('getPhysicalOrders_result')
30942 
    if self.success is not None:
30943 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30944 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30945 
      for iter729 in self.success:
30946 
        iter729.write(oprot)
30947 
      oprot.writeListEnd()
30948 
      oprot.writeFieldEnd()
30949 
    oprot.writeFieldStop()
30950 
    oprot.writeStructEnd()
30951 
 
30952 
  def validate(self):
30953 
    return
30954 
 
30955 
 
30956 
  def __repr__(self):
30957 
    L = ['%s=%r' % (key, value)
30958 
      for key, value in self.__dict__.iteritems()]
30959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30960 
 
30961 
  def __eq__(self, other):
30962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30963 
 
30964 
  def __ne__(self, other):
30965 
    return not (self == other)
6906 rajveer 30966 
 
30967 
class getDocument_args:
30968 
  """
30969 
  Attributes:
30970 
   - docType
30971 
   - docSource
30972 
  """
30973 
 
30974 
  thrift_spec = (
30975 
    None, # 0
30976 
    (1, TType.I64, 'docType', None, None, ), # 1
30977 
    (2, TType.I64, 'docSource', None, None, ), # 2
30978 
  )
30979 
 
30980 
  def __init__(self, docType=None, docSource=None,):
30981 
    self.docType = docType
30982 
    self.docSource = docSource
30983 
 
30984 
  def read(self, iprot):
30985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30987 
      return
30988 
    iprot.readStructBegin()
30989 
    while True:
30990 
      (fname, ftype, fid) = iprot.readFieldBegin()
30991 
      if ftype == TType.STOP:
30992 
        break
30993 
      if fid == 1:
30994 
        if ftype == TType.I64:
30995 
          self.docType = iprot.readI64();
30996 
        else:
30997 
          iprot.skip(ftype)
30998 
      elif fid == 2:
30999 
        if ftype == TType.I64:
31000 
          self.docSource = iprot.readI64();
31001 
        else:
31002 
          iprot.skip(ftype)
31003 
      else:
31004 
        iprot.skip(ftype)
31005 
      iprot.readFieldEnd()
31006 
    iprot.readStructEnd()
31007 
 
31008 
  def write(self, oprot):
31009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31011 
      return
31012 
    oprot.writeStructBegin('getDocument_args')
31013 
    if self.docType is not None:
31014 
      oprot.writeFieldBegin('docType', TType.I64, 1)
31015 
      oprot.writeI64(self.docType)
31016 
      oprot.writeFieldEnd()
31017 
    if self.docSource is not None:
31018 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
31019 
      oprot.writeI64(self.docSource)
31020 
      oprot.writeFieldEnd()
31021 
    oprot.writeFieldStop()
31022 
    oprot.writeStructEnd()
31023 
 
31024 
  def validate(self):
31025 
    return
31026 
 
31027 
 
31028 
  def __repr__(self):
31029 
    L = ['%s=%r' % (key, value)
31030 
      for key, value in self.__dict__.iteritems()]
31031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31032 
 
31033 
  def __eq__(self, other):
31034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31035 
 
31036 
  def __ne__(self, other):
31037 
    return not (self == other)
31038 
 
31039 
class getDocument_result:
31040 
  """
31041 
  Attributes:
31042 
   - success
31043 
  """
31044 
 
31045 
  thrift_spec = (
31046 
    (0, TType.STRING, 'success', None, None, ), # 0
31047 
  )
31048 
 
31049 
  def __init__(self, success=None,):
31050 
    self.success = success
31051 
 
31052 
  def read(self, iprot):
31053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31055 
      return
31056 
    iprot.readStructBegin()
31057 
    while True:
31058 
      (fname, ftype, fid) = iprot.readFieldBegin()
31059 
      if ftype == TType.STOP:
31060 
        break
31061 
      if fid == 0:
31062 
        if ftype == TType.STRING:
31063 
          self.success = iprot.readString();
31064 
        else:
31065 
          iprot.skip(ftype)
31066 
      else:
31067 
        iprot.skip(ftype)
31068 
      iprot.readFieldEnd()
31069 
    iprot.readStructEnd()
31070 
 
31071 
  def write(self, oprot):
31072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31074 
      return
31075 
    oprot.writeStructBegin('getDocument_result')
31076 
    if self.success is not None:
31077 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31078 
      oprot.writeString(self.success)
31079 
      oprot.writeFieldEnd()
31080 
    oprot.writeFieldStop()
31081 
    oprot.writeStructEnd()
31082 
 
31083 
  def validate(self):
31084 
    return
31085 
 
31086 
 
31087 
  def __repr__(self):
31088 
    L = ['%s=%r' % (key, value)
31089 
      for key, value in self.__dict__.iteritems()]
31090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31091 
 
31092 
  def __eq__(self, other):
31093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31094 
 
31095 
  def __ne__(self, other):
31096 
    return not (self == other)
6985 anupam.sin 31097 
 
31098 
class changeShippingAddress_args:
31099 
  """
31100 
  Attributes:
31101 
   - orderId
31102 
   - line1
31103 
   - line2
31104 
   - city
31105 
   - state
31106 
   - pin
31107 
  """
31108 
 
31109 
  thrift_spec = (
31110 
    None, # 0
31111 
    (1, TType.I64, 'orderId', None, None, ), # 1
31112 
    (2, TType.STRING, 'line1', None, None, ), # 2
31113 
    (3, TType.STRING, 'line2', None, None, ), # 3
31114 
    (4, TType.STRING, 'city', None, None, ), # 4
31115 
    (5, TType.STRING, 'state', None, None, ), # 5
31116 
    (6, TType.STRING, 'pin', None, None, ), # 6
31117 
  )
31118 
 
31119 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
31120 
    self.orderId = orderId
31121 
    self.line1 = line1
31122 
    self.line2 = line2
31123 
    self.city = city
31124 
    self.state = state
31125 
    self.pin = pin
31126 
 
31127 
  def read(self, iprot):
31128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31130 
      return
31131 
    iprot.readStructBegin()
31132 
    while True:
31133 
      (fname, ftype, fid) = iprot.readFieldBegin()
31134 
      if ftype == TType.STOP:
31135 
        break
31136 
      if fid == 1:
31137 
        if ftype == TType.I64:
31138 
          self.orderId = iprot.readI64();
31139 
        else:
31140 
          iprot.skip(ftype)
31141 
      elif fid == 2:
31142 
        if ftype == TType.STRING:
31143 
          self.line1 = iprot.readString();
31144 
        else:
31145 
          iprot.skip(ftype)
31146 
      elif fid == 3:
31147 
        if ftype == TType.STRING:
31148 
          self.line2 = iprot.readString();
31149 
        else:
31150 
          iprot.skip(ftype)
31151 
      elif fid == 4:
31152 
        if ftype == TType.STRING:
31153 
          self.city = iprot.readString();
31154 
        else:
31155 
          iprot.skip(ftype)
31156 
      elif fid == 5:
31157 
        if ftype == TType.STRING:
31158 
          self.state = iprot.readString();
31159 
        else:
31160 
          iprot.skip(ftype)
31161 
      elif fid == 6:
31162 
        if ftype == TType.STRING:
31163 
          self.pin = iprot.readString();
31164 
        else:
31165 
          iprot.skip(ftype)
31166 
      else:
31167 
        iprot.skip(ftype)
31168 
      iprot.readFieldEnd()
31169 
    iprot.readStructEnd()
31170 
 
31171 
  def write(self, oprot):
31172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31174 
      return
31175 
    oprot.writeStructBegin('changeShippingAddress_args')
31176 
    if self.orderId is not None:
31177 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
31178 
      oprot.writeI64(self.orderId)
31179 
      oprot.writeFieldEnd()
31180 
    if self.line1 is not None:
31181 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
31182 
      oprot.writeString(self.line1)
31183 
      oprot.writeFieldEnd()
31184 
    if self.line2 is not None:
31185 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
31186 
      oprot.writeString(self.line2)
31187 
      oprot.writeFieldEnd()
31188 
    if self.city is not None:
31189 
      oprot.writeFieldBegin('city', TType.STRING, 4)
31190 
      oprot.writeString(self.city)
31191 
      oprot.writeFieldEnd()
31192 
    if self.state is not None:
31193 
      oprot.writeFieldBegin('state', TType.STRING, 5)
31194 
      oprot.writeString(self.state)
31195 
      oprot.writeFieldEnd()
31196 
    if self.pin is not None:
31197 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
31198 
      oprot.writeString(self.pin)
31199 
      oprot.writeFieldEnd()
31200 
    oprot.writeFieldStop()
31201 
    oprot.writeStructEnd()
31202 
 
31203 
  def validate(self):
31204 
    return
31205 
 
31206 
 
31207 
  def __repr__(self):
31208 
    L = ['%s=%r' % (key, value)
31209 
      for key, value in self.__dict__.iteritems()]
31210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31211 
 
31212 
  def __eq__(self, other):
31213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31214 
 
31215 
  def __ne__(self, other):
31216 
    return not (self == other)
31217 
 
31218 
class changeShippingAddress_result:
31219 
  """
31220 
  Attributes:
31221 
   - success
31222 
  """
31223 
 
31224 
  thrift_spec = (
31225 
    (0, TType.BOOL, 'success', None, None, ), # 0
31226 
  )
31227 
 
31228 
  def __init__(self, success=None,):
31229 
    self.success = success
31230 
 
31231 
  def read(self, iprot):
31232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31234 
      return
31235 
    iprot.readStructBegin()
31236 
    while True:
31237 
      (fname, ftype, fid) = iprot.readFieldBegin()
31238 
      if ftype == TType.STOP:
31239 
        break
31240 
      if fid == 0:
31241 
        if ftype == TType.BOOL:
31242 
          self.success = iprot.readBool();
31243 
        else:
31244 
          iprot.skip(ftype)
31245 
      else:
31246 
        iprot.skip(ftype)
31247 
      iprot.readFieldEnd()
31248 
    iprot.readStructEnd()
31249 
 
31250 
  def write(self, oprot):
31251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31253 
      return
31254 
    oprot.writeStructBegin('changeShippingAddress_result')
31255 
    if self.success is not None:
31256 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
31257 
      oprot.writeBool(self.success)
31258 
      oprot.writeFieldEnd()
31259 
    oprot.writeFieldStop()
31260 
    oprot.writeStructEnd()
31261 
 
31262 
  def validate(self):
31263 
    return
31264 
 
31265 
 
31266 
  def __repr__(self):
31267 
    L = ['%s=%r' % (key, value)
31268 
      for key, value in self.__dict__.iteritems()]
31269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31270 
 
31271 
  def __eq__(self, other):
31272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31273 
 
31274 
  def __ne__(self, other):
31275 
    return not (self == other)
6988 rajveer 31276 
 
31277 
class retrieveInvoice_args:
31278 
  """
31279 
  Attributes:
31280 
   - orderId
7075 rajveer 31281 
   - userId
6988 rajveer 31282 
  """
31283 
 
31284 
  thrift_spec = (
31285 
    None, # 0
31286 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 31287 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 31288 
  )
31289 
 
7075 rajveer 31290 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 31291 
    self.orderId = orderId
7075 rajveer 31292 
    self.userId = userId
6988 rajveer 31293 
 
31294 
  def read(self, iprot):
31295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31297 
      return
31298 
    iprot.readStructBegin()
31299 
    while True:
31300 
      (fname, ftype, fid) = iprot.readFieldBegin()
31301 
      if ftype == TType.STOP:
31302 
        break
31303 
      if fid == 1:
31304 
        if ftype == TType.I64:
31305 
          self.orderId = iprot.readI64();
31306 
        else:
31307 
          iprot.skip(ftype)
7075 rajveer 31308 
      elif fid == 2:
31309 
        if ftype == TType.I64:
31310 
          self.userId = iprot.readI64();
31311 
        else:
31312 
          iprot.skip(ftype)
6988 rajveer 31313 
      else:
31314 
        iprot.skip(ftype)
31315 
      iprot.readFieldEnd()
31316 
    iprot.readStructEnd()
31317 
 
31318 
  def write(self, oprot):
31319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31321 
      return
31322 
    oprot.writeStructBegin('retrieveInvoice_args')
31323 
    if self.orderId is not None:
31324 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
31325 
      oprot.writeI64(self.orderId)
31326 
      oprot.writeFieldEnd()
7075 rajveer 31327 
    if self.userId is not None:
31328 
      oprot.writeFieldBegin('userId', TType.I64, 2)
31329 
      oprot.writeI64(self.userId)
31330 
      oprot.writeFieldEnd()
6988 rajveer 31331 
    oprot.writeFieldStop()
31332 
    oprot.writeStructEnd()
31333 
 
31334 
  def validate(self):
31335 
    return
31336 
 
31337 
 
31338 
  def __repr__(self):
31339 
    L = ['%s=%r' % (key, value)
31340 
      for key, value in self.__dict__.iteritems()]
31341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31342 
 
31343 
  def __eq__(self, other):
31344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31345 
 
31346 
  def __ne__(self, other):
31347 
    return not (self == other)
31348 
 
31349 
class retrieveInvoice_result:
31350 
  """
31351 
  Attributes:
31352 
   - success
31353 
  """
31354 
 
31355 
  thrift_spec = (
31356 
    (0, TType.STRING, 'success', None, None, ), # 0
31357 
  )
31358 
 
31359 
  def __init__(self, success=None,):
31360 
    self.success = success
31361 
 
31362 
  def read(self, iprot):
31363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31365 
      return
31366 
    iprot.readStructBegin()
31367 
    while True:
31368 
      (fname, ftype, fid) = iprot.readFieldBegin()
31369 
      if ftype == TType.STOP:
31370 
        break
31371 
      if fid == 0:
31372 
        if ftype == TType.STRING:
31373 
          self.success = iprot.readString();
31374 
        else:
31375 
          iprot.skip(ftype)
31376 
      else:
31377 
        iprot.skip(ftype)
31378 
      iprot.readFieldEnd()
31379 
    iprot.readStructEnd()
31380 
 
31381 
  def write(self, oprot):
31382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31384 
      return
31385 
    oprot.writeStructBegin('retrieveInvoice_result')
31386 
    if self.success is not None:
31387 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31388 
      oprot.writeString(self.success)
31389 
      oprot.writeFieldEnd()
31390 
    oprot.writeFieldStop()
31391 
    oprot.writeStructEnd()
31392 
 
31393 
  def validate(self):
31394 
    return
31395 
 
31396 
 
31397 
  def __repr__(self):
31398 
    L = ['%s=%r' % (key, value)
31399 
      for key, value in self.__dict__.iteritems()]
31400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31401 
 
31402 
  def __eq__(self, other):
31403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31404 
 
31405 
  def __ne__(self, other):
31406 
    return not (self == other)
7026 rajveer 31407 
 
31408 
class receiveUpdatesForRedExpress_args:
31409 
  """
31410 
  Attributes:
31411 
   - awbNumber
31412 
  """
31413 
 
31414 
  thrift_spec = (
31415 
    None, # 0
31416 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
31417 
  )
31418 
 
31419 
  def __init__(self, awbNumber=None,):
31420 
    self.awbNumber = awbNumber
31421 
 
31422 
  def read(self, iprot):
31423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31425 
      return
31426 
    iprot.readStructBegin()
31427 
    while True:
31428 
      (fname, ftype, fid) = iprot.readFieldBegin()
31429 
      if ftype == TType.STOP:
31430 
        break
31431 
      if fid == 1:
31432 
        if ftype == TType.STRING:
31433 
          self.awbNumber = iprot.readString();
31434 
        else:
31435 
          iprot.skip(ftype)
31436 
      else:
31437 
        iprot.skip(ftype)
31438 
      iprot.readFieldEnd()
31439 
    iprot.readStructEnd()
31440 
 
31441 
  def write(self, oprot):
31442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31444 
      return
31445 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
31446 
    if self.awbNumber is not None:
31447 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
31448 
      oprot.writeString(self.awbNumber)
31449 
      oprot.writeFieldEnd()
31450 
    oprot.writeFieldStop()
31451 
    oprot.writeStructEnd()
31452 
 
31453 
  def validate(self):
31454 
    return
31455 
 
31456 
 
31457 
  def __repr__(self):
31458 
    L = ['%s=%r' % (key, value)
31459 
      for key, value in self.__dict__.iteritems()]
31460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31461 
 
31462 
  def __eq__(self, other):
31463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31464 
 
31465 
  def __ne__(self, other):
31466 
    return not (self == other)
31467 
 
31468 
class receiveUpdatesForRedExpress_result:
31469 
  """
31470 
  Attributes:
31471 
   - success
31472 
  """
31473 
 
31474 
  thrift_spec = (
31475 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
31476 
  )
31477 
 
31478 
  def __init__(self, success=None,):
31479 
    self.success = success
31480 
 
31481 
  def read(self, iprot):
31482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31484 
      return
31485 
    iprot.readStructBegin()
31486 
    while True:
31487 
      (fname, ftype, fid) = iprot.readFieldBegin()
31488 
      if ftype == TType.STOP:
31489 
        break
31490 
      if fid == 0:
31491 
        if ftype == TType.LIST:
31492 
          self.success = []
31493 
          (_etype733, _size730) = iprot.readListBegin()
31494 
          for _i734 in xrange(_size730):
31495 
            _elem735 = iprot.readString();
31496 
            self.success.append(_elem735)
31497 
          iprot.readListEnd()
31498 
        else:
31499 
          iprot.skip(ftype)
31500 
      else:
31501 
        iprot.skip(ftype)
31502 
      iprot.readFieldEnd()
31503 
    iprot.readStructEnd()
31504 
 
31505 
  def write(self, oprot):
31506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31508 
      return
31509 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
31510 
    if self.success is not None:
31511 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31512 
      oprot.writeListBegin(TType.STRING, len(self.success))
31513 
      for iter736 in self.success:
31514 
        oprot.writeString(iter736)
31515 
      oprot.writeListEnd()
31516 
      oprot.writeFieldEnd()
31517 
    oprot.writeFieldStop()
31518 
    oprot.writeStructEnd()
31519 
 
31520 
  def validate(self):
31521 
    return
31522 
 
31523 
 
31524 
  def __repr__(self):
31525 
    L = ['%s=%r' % (key, value)
31526 
      for key, value in self.__dict__.iteritems()]
31527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31528 
 
31529 
  def __eq__(self, other):
31530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31531 
 
31532 
  def __ne__(self, other):
31533 
    return not (self == other)
7073 anupam.sin 31534 
 
31535 
class createRechargeTransaction_args:
31536 
  """
31537 
  Attributes:
31538 
   - thriftRechargeTransaction
31539 
  """
31540 
 
31541 
  thrift_spec = (
31542 
    None, # 0
31543 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
31544 
  )
31545 
 
31546 
  def __init__(self, thriftRechargeTransaction=None,):
31547 
    self.thriftRechargeTransaction = thriftRechargeTransaction
31548 
 
31549 
  def read(self, iprot):
31550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31552 
      return
31553 
    iprot.readStructBegin()
31554 
    while True:
31555 
      (fname, ftype, fid) = iprot.readFieldBegin()
31556 
      if ftype == TType.STOP:
31557 
        break
31558 
      if fid == 1:
31559 
        if ftype == TType.STRUCT:
31560 
          self.thriftRechargeTransaction = RechargeTransaction()
31561 
          self.thriftRechargeTransaction.read(iprot)
31562 
        else:
31563 
          iprot.skip(ftype)
31564 
      else:
31565 
        iprot.skip(ftype)
31566 
      iprot.readFieldEnd()
31567 
    iprot.readStructEnd()
31568 
 
31569 
  def write(self, oprot):
31570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31572 
      return
31573 
    oprot.writeStructBegin('createRechargeTransaction_args')
31574 
    if self.thriftRechargeTransaction is not None:
31575 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
31576 
      self.thriftRechargeTransaction.write(oprot)
31577 
      oprot.writeFieldEnd()
31578 
    oprot.writeFieldStop()
31579 
    oprot.writeStructEnd()
31580 
 
31581 
  def validate(self):
31582 
    return
31583 
 
31584 
 
31585 
  def __repr__(self):
31586 
    L = ['%s=%r' % (key, value)
31587 
      for key, value in self.__dict__.iteritems()]
31588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31589 
 
31590 
  def __eq__(self, other):
31591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31592 
 
31593 
  def __ne__(self, other):
31594 
    return not (self == other)
31595 
 
31596 
class createRechargeTransaction_result:
31597 
  """
31598 
  Attributes:
31599 
   - success
31600 
  """
31601 
 
31602 
  thrift_spec = (
31603 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31604 
  )
31605 
 
31606 
  def __init__(self, success=None,):
31607 
    self.success = success
31608 
 
31609 
  def read(self, iprot):
31610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31612 
      return
31613 
    iprot.readStructBegin()
31614 
    while True:
31615 
      (fname, ftype, fid) = iprot.readFieldBegin()
31616 
      if ftype == TType.STOP:
31617 
        break
31618 
      if fid == 0:
31619 
        if ftype == TType.STRUCT:
31620 
          self.success = RechargeTransaction()
31621 
          self.success.read(iprot)
31622 
        else:
31623 
          iprot.skip(ftype)
31624 
      else:
31625 
        iprot.skip(ftype)
31626 
      iprot.readFieldEnd()
31627 
    iprot.readStructEnd()
31628 
 
31629 
  def write(self, oprot):
31630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31632 
      return
31633 
    oprot.writeStructBegin('createRechargeTransaction_result')
31634 
    if self.success is not None:
31635 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31636 
      self.success.write(oprot)
31637 
      oprot.writeFieldEnd()
31638 
    oprot.writeFieldStop()
31639 
    oprot.writeStructEnd()
31640 
 
31641 
  def validate(self):
31642 
    return
31643 
 
31644 
 
31645 
  def __repr__(self):
31646 
    L = ['%s=%r' % (key, value)
31647 
      for key, value in self.__dict__.iteritems()]
31648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31649 
 
31650 
  def __eq__(self, other):
31651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31652 
 
31653 
  def __ne__(self, other):
31654 
    return not (self == other)
7080 anupam.sin 31655 
 
7085 rajveer 31656 
class getRechargeTransactions_args:
31657 
  """
31658 
  Attributes:
31659 
   - storeId
31660 
  """
31661 
 
31662 
  thrift_spec = (
31663 
    None, # 0
31664 
    (1, TType.I64, 'storeId', None, None, ), # 1
31665 
  )
31666 
 
31667 
  def __init__(self, storeId=None,):
31668 
    self.storeId = storeId
31669 
 
31670 
  def read(self, iprot):
31671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31673 
      return
31674 
    iprot.readStructBegin()
31675 
    while True:
31676 
      (fname, ftype, fid) = iprot.readFieldBegin()
31677 
      if ftype == TType.STOP:
31678 
        break
31679 
      if fid == 1:
31680 
        if ftype == TType.I64:
31681 
          self.storeId = iprot.readI64();
31682 
        else:
31683 
          iprot.skip(ftype)
31684 
      else:
31685 
        iprot.skip(ftype)
31686 
      iprot.readFieldEnd()
31687 
    iprot.readStructEnd()
31688 
 
31689 
  def write(self, oprot):
31690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31692 
      return
31693 
    oprot.writeStructBegin('getRechargeTransactions_args')
31694 
    if self.storeId is not None:
31695 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31696 
      oprot.writeI64(self.storeId)
31697 
      oprot.writeFieldEnd()
31698 
    oprot.writeFieldStop()
31699 
    oprot.writeStructEnd()
31700 
 
31701 
  def validate(self):
31702 
    return
31703 
 
31704 
 
31705 
  def __repr__(self):
31706 
    L = ['%s=%r' % (key, value)
31707 
      for key, value in self.__dict__.iteritems()]
31708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31709 
 
31710 
  def __eq__(self, other):
31711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31712 
 
31713 
  def __ne__(self, other):
31714 
    return not (self == other)
31715 
 
31716 
class getRechargeTransactions_result:
31717 
  """
31718 
  Attributes:
31719 
   - success
31720 
  """
31721 
 
31722 
  thrift_spec = (
31723 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31724 
  )
31725 
 
31726 
  def __init__(self, success=None,):
31727 
    self.success = success
31728 
 
31729 
  def read(self, iprot):
31730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31732 
      return
31733 
    iprot.readStructBegin()
31734 
    while True:
31735 
      (fname, ftype, fid) = iprot.readFieldBegin()
31736 
      if ftype == TType.STOP:
31737 
        break
31738 
      if fid == 0:
31739 
        if ftype == TType.LIST:
31740 
          self.success = []
31741 
          (_etype740, _size737) = iprot.readListBegin()
31742 
          for _i741 in xrange(_size737):
31743 
            _elem742 = RechargeTransaction()
31744 
            _elem742.read(iprot)
31745 
            self.success.append(_elem742)
31746 
          iprot.readListEnd()
31747 
        else:
31748 
          iprot.skip(ftype)
31749 
      else:
31750 
        iprot.skip(ftype)
31751 
      iprot.readFieldEnd()
31752 
    iprot.readStructEnd()
31753 
 
31754 
  def write(self, oprot):
31755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31757 
      return
31758 
    oprot.writeStructBegin('getRechargeTransactions_result')
31759 
    if self.success is not None:
31760 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31761 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31762 
      for iter743 in self.success:
31763 
        iter743.write(oprot)
31764 
      oprot.writeListEnd()
31765 
      oprot.writeFieldEnd()
31766 
    oprot.writeFieldStop()
31767 
    oprot.writeStructEnd()
31768 
 
31769 
  def validate(self):
31770 
    return
31771 
 
31772 
 
31773 
  def __repr__(self):
31774 
    L = ['%s=%r' % (key, value)
31775 
      for key, value in self.__dict__.iteritems()]
31776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31777 
 
31778 
  def __eq__(self, other):
31779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31780 
 
31781 
  def __ne__(self, other):
31782 
    return not (self == other)
31783 
 
7151 amit.gupta 31784 
class getRechargeTrans_args:
31785 
  """
31786 
  Attributes:
31787 
   - storeId
31788 
   - startDate
31789 
   - endDate
31790 
   - status
31791 
  """
31792 
 
31793 
  thrift_spec = (
31794 
    None, # 0
31795 
    (1, TType.I64, 'storeId', None, None, ), # 1
31796 
    (2, TType.I64, 'startDate', None, None, ), # 2
31797 
    (3, TType.I64, 'endDate', None, None, ), # 3
31798 
    (4, TType.I32, 'status', None, None, ), # 4
31799 
  )
31800 
 
31801 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31802 
    self.storeId = storeId
31803 
    self.startDate = startDate
31804 
    self.endDate = endDate
31805 
    self.status = status
31806 
 
31807 
  def read(self, iprot):
31808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31810 
      return
31811 
    iprot.readStructBegin()
31812 
    while True:
31813 
      (fname, ftype, fid) = iprot.readFieldBegin()
31814 
      if ftype == TType.STOP:
31815 
        break
31816 
      if fid == 1:
31817 
        if ftype == TType.I64:
31818 
          self.storeId = iprot.readI64();
31819 
        else:
31820 
          iprot.skip(ftype)
31821 
      elif fid == 2:
31822 
        if ftype == TType.I64:
31823 
          self.startDate = iprot.readI64();
31824 
        else:
31825 
          iprot.skip(ftype)
31826 
      elif fid == 3:
31827 
        if ftype == TType.I64:
31828 
          self.endDate = iprot.readI64();
31829 
        else:
31830 
          iprot.skip(ftype)
31831 
      elif fid == 4:
31832 
        if ftype == TType.I32:
31833 
          self.status = iprot.readI32();
31834 
        else:
31835 
          iprot.skip(ftype)
31836 
      else:
31837 
        iprot.skip(ftype)
31838 
      iprot.readFieldEnd()
31839 
    iprot.readStructEnd()
31840 
 
31841 
  def write(self, oprot):
31842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31844 
      return
31845 
    oprot.writeStructBegin('getRechargeTrans_args')
31846 
    if self.storeId is not None:
31847 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31848 
      oprot.writeI64(self.storeId)
31849 
      oprot.writeFieldEnd()
31850 
    if self.startDate is not None:
31851 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
31852 
      oprot.writeI64(self.startDate)
31853 
      oprot.writeFieldEnd()
31854 
    if self.endDate is not None:
31855 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
31856 
      oprot.writeI64(self.endDate)
31857 
      oprot.writeFieldEnd()
31858 
    if self.status is not None:
31859 
      oprot.writeFieldBegin('status', TType.I32, 4)
31860 
      oprot.writeI32(self.status)
31861 
      oprot.writeFieldEnd()
31862 
    oprot.writeFieldStop()
31863 
    oprot.writeStructEnd()
31864 
 
31865 
  def validate(self):
31866 
    return
31867 
 
31868 
 
31869 
  def __repr__(self):
31870 
    L = ['%s=%r' % (key, value)
31871 
      for key, value in self.__dict__.iteritems()]
31872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31873 
 
31874 
  def __eq__(self, other):
31875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31876 
 
31877 
  def __ne__(self, other):
31878 
    return not (self == other)
31879 
 
31880 
class getRechargeTrans_result:
31881 
  """
31882 
  Attributes:
31883 
   - success
31884 
  """
31885 
 
31886 
  thrift_spec = (
31887 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31888 
  )
31889 
 
31890 
  def __init__(self, success=None,):
31891 
    self.success = success
31892 
 
31893 
  def read(self, iprot):
31894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31896 
      return
31897 
    iprot.readStructBegin()
31898 
    while True:
31899 
      (fname, ftype, fid) = iprot.readFieldBegin()
31900 
      if ftype == TType.STOP:
31901 
        break
31902 
      if fid == 0:
31903 
        if ftype == TType.LIST:
31904 
          self.success = []
31905 
          (_etype747, _size744) = iprot.readListBegin()
31906 
          for _i748 in xrange(_size744):
31907 
            _elem749 = RechargeTransaction()
31908 
            _elem749.read(iprot)
31909 
            self.success.append(_elem749)
31910 
          iprot.readListEnd()
31911 
        else:
31912 
          iprot.skip(ftype)
31913 
      else:
31914 
        iprot.skip(ftype)
31915 
      iprot.readFieldEnd()
31916 
    iprot.readStructEnd()
31917 
 
31918 
  def write(self, oprot):
31919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31921 
      return
31922 
    oprot.writeStructBegin('getRechargeTrans_result')
31923 
    if self.success is not None:
31924 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31925 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31926 
      for iter750 in self.success:
31927 
        iter750.write(oprot)
31928 
      oprot.writeListEnd()
31929 
      oprot.writeFieldEnd()
31930 
    oprot.writeFieldStop()
31931 
    oprot.writeStructEnd()
31932 
 
31933 
  def validate(self):
31934 
    return
31935 
 
31936 
 
31937 
  def __repr__(self):
31938 
    L = ['%s=%r' % (key, value)
31939 
      for key, value in self.__dict__.iteritems()]
31940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31941 
 
31942 
  def __eq__(self, other):
31943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31944 
 
31945 
  def __ne__(self, other):
31946 
    return not (self == other)
31947 
 
7080 anupam.sin 31948 
class getRechargeTransaction_args:
31949 
  """
31950 
  Attributes:
31951 
   - rechargeId
31952 
  """
31953 
 
31954 
  thrift_spec = (
31955 
    None, # 0
31956 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31957 
  )
31958 
 
31959 
  def __init__(self, rechargeId=None,):
31960 
    self.rechargeId = rechargeId
31961 
 
31962 
  def read(self, iprot):
31963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31965 
      return
31966 
    iprot.readStructBegin()
31967 
    while True:
31968 
      (fname, ftype, fid) = iprot.readFieldBegin()
31969 
      if ftype == TType.STOP:
31970 
        break
31971 
      if fid == 1:
31972 
        if ftype == TType.I64:
31973 
          self.rechargeId = iprot.readI64();
31974 
        else:
31975 
          iprot.skip(ftype)
31976 
      else:
31977 
        iprot.skip(ftype)
31978 
      iprot.readFieldEnd()
31979 
    iprot.readStructEnd()
31980 
 
31981 
  def write(self, oprot):
31982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31984 
      return
31985 
    oprot.writeStructBegin('getRechargeTransaction_args')
31986 
    if self.rechargeId is not None:
31987 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31988 
      oprot.writeI64(self.rechargeId)
31989 
      oprot.writeFieldEnd()
31990 
    oprot.writeFieldStop()
31991 
    oprot.writeStructEnd()
31992 
 
31993 
  def validate(self):
31994 
    return
31995 
 
31996 
 
31997 
  def __repr__(self):
31998 
    L = ['%s=%r' % (key, value)
31999 
      for key, value in self.__dict__.iteritems()]
32000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32001 
 
32002 
  def __eq__(self, other):
32003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32004 
 
32005 
  def __ne__(self, other):
32006 
    return not (self == other)
32007 
 
32008 
class getRechargeTransaction_result:
32009 
  """
32010 
  Attributes:
32011 
   - success
32012 
  """
32013 
 
32014 
  thrift_spec = (
32015 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
32016 
  )
32017 
 
32018 
  def __init__(self, success=None,):
32019 
    self.success = success
32020 
 
32021 
  def read(self, iprot):
32022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32024 
      return
32025 
    iprot.readStructBegin()
32026 
    while True:
32027 
      (fname, ftype, fid) = iprot.readFieldBegin()
32028 
      if ftype == TType.STOP:
32029 
        break
32030 
      if fid == 0:
32031 
        if ftype == TType.STRUCT:
32032 
          self.success = RechargeTransaction()
32033 
          self.success.read(iprot)
32034 
        else:
32035 
          iprot.skip(ftype)
32036 
      else:
32037 
        iprot.skip(ftype)
32038 
      iprot.readFieldEnd()
32039 
    iprot.readStructEnd()
32040 
 
32041 
  def write(self, oprot):
32042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32044 
      return
32045 
    oprot.writeStructBegin('getRechargeTransaction_result')
32046 
    if self.success is not None:
32047 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32048 
      self.success.write(oprot)
32049 
      oprot.writeFieldEnd()
32050 
    oprot.writeFieldStop()
32051 
    oprot.writeStructEnd()
32052 
 
32053 
  def validate(self):
32054 
    return
32055 
 
32056 
 
32057 
  def __repr__(self):
32058 
    L = ['%s=%r' % (key, value)
32059 
      for key, value in self.__dict__.iteritems()]
32060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32061 
 
32062 
  def __eq__(self, other):
32063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32064 
 
32065 
  def __ne__(self, other):
32066 
    return not (self == other)
32067 
 
32068 
class getFRCs_args:
32069 
  """
32070 
  Attributes:
32071 
   - circleId
32072 
   - operatorId
32073 
  """
32074 
 
32075 
  thrift_spec = (
32076 
    None, # 0
32077 
    (1, TType.I64, 'circleId', None, None, ), # 1
32078 
    (2, TType.I64, 'operatorId', None, None, ), # 2
32079 
  )
32080 
 
32081 
  def __init__(self, circleId=None, operatorId=None,):
32082 
    self.circleId = circleId
32083 
    self.operatorId = operatorId
32084 
 
32085 
  def read(self, iprot):
32086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32088 
      return
32089 
    iprot.readStructBegin()
32090 
    while True:
32091 
      (fname, ftype, fid) = iprot.readFieldBegin()
32092 
      if ftype == TType.STOP:
32093 
        break
32094 
      if fid == 1:
32095 
        if ftype == TType.I64:
32096 
          self.circleId = iprot.readI64();
32097 
        else:
32098 
          iprot.skip(ftype)
32099 
      elif fid == 2:
32100 
        if ftype == TType.I64:
32101 
          self.operatorId = iprot.readI64();
32102 
        else:
32103 
          iprot.skip(ftype)
32104 
      else:
32105 
        iprot.skip(ftype)
32106 
      iprot.readFieldEnd()
32107 
    iprot.readStructEnd()
32108 
 
32109 
  def write(self, oprot):
32110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32112 
      return
32113 
    oprot.writeStructBegin('getFRCs_args')
32114 
    if self.circleId is not None:
32115 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
32116 
      oprot.writeI64(self.circleId)
32117 
      oprot.writeFieldEnd()
32118 
    if self.operatorId is not None:
32119 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
32120 
      oprot.writeI64(self.operatorId)
32121 
      oprot.writeFieldEnd()
32122 
    oprot.writeFieldStop()
32123 
    oprot.writeStructEnd()
32124 
 
32125 
  def validate(self):
32126 
    return
32127 
 
32128 
 
32129 
  def __repr__(self):
32130 
    L = ['%s=%r' % (key, value)
32131 
      for key, value in self.__dict__.iteritems()]
32132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32133 
 
32134 
  def __eq__(self, other):
32135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32136 
 
32137 
  def __ne__(self, other):
32138 
    return not (self == other)
32139 
 
32140 
class getFRCs_result:
32141 
  """
32142 
  Attributes:
32143 
   - success
32144 
  """
32145 
 
32146 
  thrift_spec = (
32147 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
32148 
  )
32149 
 
32150 
  def __init__(self, success=None,):
32151 
    self.success = success
32152 
 
32153 
  def read(self, iprot):
32154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32156 
      return
32157 
    iprot.readStructBegin()
32158 
    while True:
32159 
      (fname, ftype, fid) = iprot.readFieldBegin()
32160 
      if ftype == TType.STOP:
32161 
        break
32162 
      if fid == 0:
32163 
        if ftype == TType.LIST:
32164 
          self.success = []
7151 amit.gupta 32165 
          (_etype754, _size751) = iprot.readListBegin()
32166 
          for _i755 in xrange(_size751):
32167 
            _elem756 = FRC()
32168 
            _elem756.read(iprot)
32169 
            self.success.append(_elem756)
7080 anupam.sin 32170 
          iprot.readListEnd()
32171 
        else:
32172 
          iprot.skip(ftype)
32173 
      else:
32174 
        iprot.skip(ftype)
32175 
      iprot.readFieldEnd()
32176 
    iprot.readStructEnd()
32177 
 
32178 
  def write(self, oprot):
32179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32181 
      return
32182 
    oprot.writeStructBegin('getFRCs_result')
32183 
    if self.success is not None:
32184 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32185 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 32186 
      for iter757 in self.success:
32187 
        iter757.write(oprot)
7080 anupam.sin 32188 
      oprot.writeListEnd()
32189 
      oprot.writeFieldEnd()
32190 
    oprot.writeFieldStop()
32191 
    oprot.writeStructEnd()
32192 
 
32193 
  def validate(self):
32194 
    return
32195 
 
32196 
 
32197 
  def __repr__(self):
32198 
    L = ['%s=%r' % (key, value)
32199 
      for key, value in self.__dict__.iteritems()]
32200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32201 
 
32202 
  def __eq__(self, other):
32203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32204 
 
32205 
  def __ne__(self, other):
32206 
    return not (self == other)
7096 anupam.sin 32207 
 
32208 
class getHotspotStore_args:
32209 
  """
32210 
  Attributes:
32211 
   - id
32212 
   - hotspotid
32213 
  """
32214 
 
32215 
  thrift_spec = (
32216 
    None, # 0
32217 
    (1, TType.I64, 'id', None, None, ), # 1
32218 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
32219 
  )
32220 
 
32221 
  def __init__(self, id=None, hotspotid=None,):
32222 
    self.id = id
32223 
    self.hotspotid = hotspotid
32224 
 
32225 
  def read(self, iprot):
32226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32228 
      return
32229 
    iprot.readStructBegin()
32230 
    while True:
32231 
      (fname, ftype, fid) = iprot.readFieldBegin()
32232 
      if ftype == TType.STOP:
32233 
        break
32234 
      if fid == 1:
32235 
        if ftype == TType.I64:
32236 
          self.id = iprot.readI64();
32237 
        else:
32238 
          iprot.skip(ftype)
32239 
      elif fid == 2:
32240 
        if ftype == TType.STRING:
32241 
          self.hotspotid = iprot.readString();
32242 
        else:
32243 
          iprot.skip(ftype)
32244 
      else:
32245 
        iprot.skip(ftype)
32246 
      iprot.readFieldEnd()
32247 
    iprot.readStructEnd()
32248 
 
32249 
  def write(self, oprot):
32250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32252 
      return
32253 
    oprot.writeStructBegin('getHotspotStore_args')
32254 
    if self.id is not None:
32255 
      oprot.writeFieldBegin('id', TType.I64, 1)
32256 
      oprot.writeI64(self.id)
32257 
      oprot.writeFieldEnd()
32258 
    if self.hotspotid is not None:
32259 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
32260 
      oprot.writeString(self.hotspotid)
32261 
      oprot.writeFieldEnd()
32262 
    oprot.writeFieldStop()
32263 
    oprot.writeStructEnd()
32264 
 
32265 
  def validate(self):
32266 
    return
32267 
 
32268 
 
32269 
  def __repr__(self):
32270 
    L = ['%s=%r' % (key, value)
32271 
      for key, value in self.__dict__.iteritems()]
32272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32273 
 
32274 
  def __eq__(self, other):
32275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32276 
 
32277 
  def __ne__(self, other):
32278 
    return not (self == other)
32279 
 
32280 
class getHotspotStore_result:
32281 
  """
32282 
  Attributes:
32283 
   - success
32284 
  """
32285 
 
32286 
  thrift_spec = (
32287 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
32288 
  )
32289 
 
32290 
  def __init__(self, success=None,):
32291 
    self.success = success
32292 
 
32293 
  def read(self, iprot):
32294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32296 
      return
32297 
    iprot.readStructBegin()
32298 
    while True:
32299 
      (fname, ftype, fid) = iprot.readFieldBegin()
32300 
      if ftype == TType.STOP:
32301 
        break
32302 
      if fid == 0:
32303 
        if ftype == TType.STRUCT:
32304 
          self.success = HotspotStore()
32305 
          self.success.read(iprot)
32306 
        else:
32307 
          iprot.skip(ftype)
32308 
      else:
32309 
        iprot.skip(ftype)
32310 
      iprot.readFieldEnd()
32311 
    iprot.readStructEnd()
32312 
 
32313 
  def write(self, oprot):
32314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32316 
      return
32317 
    oprot.writeStructBegin('getHotspotStore_result')
32318 
    if self.success is not None:
32319 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32320 
      self.success.write(oprot)
32321 
      oprot.writeFieldEnd()
32322 
    oprot.writeFieldStop()
32323 
    oprot.writeStructEnd()
32324 
 
32325 
  def validate(self):
32326 
    return
32327 
 
32328 
 
32329 
  def __repr__(self):
32330 
    L = ['%s=%r' % (key, value)
32331 
      for key, value in self.__dict__.iteritems()]
32332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32333 
 
32334 
  def __eq__(self, other):
32335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32336 
 
32337 
  def __ne__(self, other):
32338 
    return not (self == other)
32339 
 
32340 
class getTelecomCircle_args:
32341 
  """
32342 
  Attributes:
32343 
   - id
32344 
   - code
32345 
  """
32346 
 
32347 
  thrift_spec = (
32348 
    None, # 0
32349 
    (1, TType.I64, 'id', None, None, ), # 1
32350 
    (2, TType.STRING, 'code', None, None, ), # 2
32351 
  )
32352 
 
32353 
  def __init__(self, id=None, code=None,):
32354 
    self.id = id
32355 
    self.code = code
32356 
 
32357 
  def read(self, iprot):
32358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32360 
      return
32361 
    iprot.readStructBegin()
32362 
    while True:
32363 
      (fname, ftype, fid) = iprot.readFieldBegin()
32364 
      if ftype == TType.STOP:
32365 
        break
32366 
      if fid == 1:
32367 
        if ftype == TType.I64:
32368 
          self.id = iprot.readI64();
32369 
        else:
32370 
          iprot.skip(ftype)
32371 
      elif fid == 2:
32372 
        if ftype == TType.STRING:
32373 
          self.code = iprot.readString();
32374 
        else:
32375 
          iprot.skip(ftype)
32376 
      else:
32377 
        iprot.skip(ftype)
32378 
      iprot.readFieldEnd()
32379 
    iprot.readStructEnd()
32380 
 
32381 
  def write(self, oprot):
32382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32384 
      return
32385 
    oprot.writeStructBegin('getTelecomCircle_args')
32386 
    if self.id is not None:
32387 
      oprot.writeFieldBegin('id', TType.I64, 1)
32388 
      oprot.writeI64(self.id)
32389 
      oprot.writeFieldEnd()
32390 
    if self.code is not None:
32391 
      oprot.writeFieldBegin('code', TType.STRING, 2)
32392 
      oprot.writeString(self.code)
32393 
      oprot.writeFieldEnd()
32394 
    oprot.writeFieldStop()
32395 
    oprot.writeStructEnd()
32396 
 
32397 
  def validate(self):
32398 
    return
32399 
 
32400 
 
32401 
  def __repr__(self):
32402 
    L = ['%s=%r' % (key, value)
32403 
      for key, value in self.__dict__.iteritems()]
32404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32405 
 
32406 
  def __eq__(self, other):
32407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32408 
 
32409 
  def __ne__(self, other):
32410 
    return not (self == other)
32411 
 
32412 
class getTelecomCircle_result:
32413 
  """
32414 
  Attributes:
32415 
   - success
32416 
  """
32417 
 
32418 
  thrift_spec = (
32419 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
32420 
  )
32421 
 
32422 
  def __init__(self, success=None,):
32423 
    self.success = success
32424 
 
32425 
  def read(self, iprot):
32426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32428 
      return
32429 
    iprot.readStructBegin()
32430 
    while True:
32431 
      (fname, ftype, fid) = iprot.readFieldBegin()
32432 
      if ftype == TType.STOP:
32433 
        break
32434 
      if fid == 0:
32435 
        if ftype == TType.STRUCT:
32436 
          self.success = TelecomCircle()
32437 
          self.success.read(iprot)
32438 
        else:
32439 
          iprot.skip(ftype)
32440 
      else:
32441 
        iprot.skip(ftype)
32442 
      iprot.readFieldEnd()
32443 
    iprot.readStructEnd()
32444 
 
32445 
  def write(self, oprot):
32446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32448 
      return
32449 
    oprot.writeStructBegin('getTelecomCircle_result')
32450 
    if self.success is not None:
32451 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32452 
      self.success.write(oprot)
32453 
      oprot.writeFieldEnd()
32454 
    oprot.writeFieldStop()
32455 
    oprot.writeStructEnd()
32456 
 
32457 
  def validate(self):
32458 
    return
32459 
 
32460 
 
32461 
  def __repr__(self):
32462 
    L = ['%s=%r' % (key, value)
32463 
      for key, value in self.__dict__.iteritems()]
32464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32465 
 
32466 
  def __eq__(self, other):
32467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32468 
 
32469 
  def __ne__(self, other):
32470 
    return not (self == other)
7109 anupam.sin 32471 
 
32472 
class retrieveHotspotRechargeInvoice_args:
32473 
  """
32474 
  Attributes:
32475 
   - rechargeId
32476 
  """
32477 
 
32478 
  thrift_spec = (
32479 
    None, # 0
32480 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
32481 
  )
32482 
 
32483 
  def __init__(self, rechargeId=None,):
32484 
    self.rechargeId = rechargeId
32485 
 
32486 
  def read(self, iprot):
32487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32489 
      return
32490 
    iprot.readStructBegin()
32491 
    while True:
32492 
      (fname, ftype, fid) = iprot.readFieldBegin()
32493 
      if ftype == TType.STOP:
32494 
        break
32495 
      if fid == 1:
32496 
        if ftype == TType.I64:
32497 
          self.rechargeId = iprot.readI64();
32498 
        else:
32499 
          iprot.skip(ftype)
32500 
      else:
32501 
        iprot.skip(ftype)
32502 
      iprot.readFieldEnd()
32503 
    iprot.readStructEnd()
32504 
 
32505 
  def write(self, oprot):
32506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32508 
      return
32509 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
32510 
    if self.rechargeId is not None:
32511 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
32512 
      oprot.writeI64(self.rechargeId)
32513 
      oprot.writeFieldEnd()
32514 
    oprot.writeFieldStop()
32515 
    oprot.writeStructEnd()
32516 
 
32517 
  def validate(self):
32518 
    return
32519 
 
32520 
 
32521 
  def __repr__(self):
32522 
    L = ['%s=%r' % (key, value)
32523 
      for key, value in self.__dict__.iteritems()]
32524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32525 
 
32526 
  def __eq__(self, other):
32527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32528 
 
32529 
  def __ne__(self, other):
32530 
    return not (self == other)
32531 
 
32532 
class retrieveHotspotRechargeInvoice_result:
32533 
  """
32534 
  Attributes:
32535 
   - success
32536 
  """
32537 
 
32538 
  thrift_spec = (
32539 
    (0, TType.STRING, 'success', None, None, ), # 0
32540 
  )
32541 
 
32542 
  def __init__(self, success=None,):
32543 
    self.success = success
32544 
 
32545 
  def read(self, iprot):
32546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32548 
      return
32549 
    iprot.readStructBegin()
32550 
    while True:
32551 
      (fname, ftype, fid) = iprot.readFieldBegin()
32552 
      if ftype == TType.STOP:
32553 
        break
32554 
      if fid == 0:
32555 
        if ftype == TType.STRING:
32556 
          self.success = iprot.readString();
32557 
        else:
32558 
          iprot.skip(ftype)
32559 
      else:
32560 
        iprot.skip(ftype)
32561 
      iprot.readFieldEnd()
32562 
    iprot.readStructEnd()
32563 
 
32564 
  def write(self, oprot):
32565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32567 
      return
32568 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
32569 
    if self.success is not None:
32570 
      oprot.writeFieldBegin('success', TType.STRING, 0)
32571 
      oprot.writeString(self.success)
32572 
      oprot.writeFieldEnd()
32573 
    oprot.writeFieldStop()
32574 
    oprot.writeStructEnd()
32575 
 
32576 
  def validate(self):
32577 
    return
32578 
 
32579 
 
32580 
  def __repr__(self):
32581 
    L = ['%s=%r' % (key, value)
32582 
      for key, value in self.__dict__.iteritems()]
32583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32584 
 
32585 
  def __eq__(self, other):
32586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32587 
 
32588 
  def __ne__(self, other):
32589 
    return not (self == other)
7169 anupam.sin 32590 
 
7190 amar.kumar 32591 
class splitFreebieOrder_args:
32592 
  """
32593 
  Attributes:
32594 
   - orderId
32595 
   - splitReason
32596 
   - shippingDate
32597 
  """
32598 
 
32599 
  thrift_spec = (
32600 
    None, # 0
32601 
    (1, TType.I64, 'orderId', None, None, ), # 1
32602 
    (2, TType.STRING, 'splitReason', None, None, ), # 2
32603 
    (3, TType.I64, 'shippingDate', None, None, ), # 3
32604 
  )
32605 
 
32606 
  def __init__(self, orderId=None, splitReason=None, shippingDate=None,):
32607 
    self.orderId = orderId
32608 
    self.splitReason = splitReason
32609 
    self.shippingDate = shippingDate
32610 
 
32611 
  def read(self, iprot):
32612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32614 
      return
32615 
    iprot.readStructBegin()
32616 
    while True:
32617 
      (fname, ftype, fid) = iprot.readFieldBegin()
32618 
      if ftype == TType.STOP:
32619 
        break
32620 
      if fid == 1:
32621 
        if ftype == TType.I64:
32622 
          self.orderId = iprot.readI64();
32623 
        else:
32624 
          iprot.skip(ftype)
32625 
      elif fid == 2:
32626 
        if ftype == TType.STRING:
32627 
          self.splitReason = iprot.readString();
32628 
        else:
32629 
          iprot.skip(ftype)
32630 
      elif fid == 3:
32631 
        if ftype == TType.I64:
32632 
          self.shippingDate = iprot.readI64();
32633 
        else:
32634 
          iprot.skip(ftype)
32635 
      else:
32636 
        iprot.skip(ftype)
32637 
      iprot.readFieldEnd()
32638 
    iprot.readStructEnd()
32639 
 
32640 
  def write(self, oprot):
32641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32643 
      return
32644 
    oprot.writeStructBegin('splitFreebieOrder_args')
32645 
    if self.orderId is not None:
32646 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
32647 
      oprot.writeI64(self.orderId)
32648 
      oprot.writeFieldEnd()
32649 
    if self.splitReason is not None:
32650 
      oprot.writeFieldBegin('splitReason', TType.STRING, 2)
32651 
      oprot.writeString(self.splitReason)
32652 
      oprot.writeFieldEnd()
32653 
    if self.shippingDate is not None:
32654 
      oprot.writeFieldBegin('shippingDate', TType.I64, 3)
32655 
      oprot.writeI64(self.shippingDate)
32656 
      oprot.writeFieldEnd()
32657 
    oprot.writeFieldStop()
32658 
    oprot.writeStructEnd()
32659 
 
32660 
  def validate(self):
32661 
    return
32662 
 
32663 
 
32664 
  def __repr__(self):
32665 
    L = ['%s=%r' % (key, value)
32666 
      for key, value in self.__dict__.iteritems()]
32667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32668 
 
32669 
  def __eq__(self, other):
32670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32671 
 
32672 
  def __ne__(self, other):
32673 
    return not (self == other)
32674 
 
32675 
class splitFreebieOrder_result:
32676 
  """
32677 
  Attributes:
32678 
   - success
32679 
  """
32680 
 
32681 
  thrift_spec = (
32682 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
32683 
  )
32684 
 
32685 
  def __init__(self, success=None,):
32686 
    self.success = success
32687 
 
32688 
  def read(self, iprot):
32689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32691 
      return
32692 
    iprot.readStructBegin()
32693 
    while True:
32694 
      (fname, ftype, fid) = iprot.readFieldBegin()
32695 
      if ftype == TType.STOP:
32696 
        break
32697 
      if fid == 0:
32698 
        if ftype == TType.STRUCT:
32699 
          self.success = Order()
32700 
          self.success.read(iprot)
32701 
        else:
32702 
          iprot.skip(ftype)
32703 
      else:
32704 
        iprot.skip(ftype)
32705 
      iprot.readFieldEnd()
32706 
    iprot.readStructEnd()
32707 
 
32708 
  def write(self, oprot):
32709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32711 
      return
32712 
    oprot.writeStructBegin('splitFreebieOrder_result')
32713 
    if self.success is not None:
32714 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32715 
      self.success.write(oprot)
32716 
      oprot.writeFieldEnd()
32717 
    oprot.writeFieldStop()
32718 
    oprot.writeStructEnd()
32719 
 
32720 
  def validate(self):
32721 
    return
32722 
 
32723 
 
32724 
  def __repr__(self):
32725 
    L = ['%s=%r' % (key, value)
32726 
      for key, value in self.__dict__.iteritems()]
32727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32728 
 
32729 
  def __eq__(self, other):
32730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32731 
 
32732 
  def __ne__(self, other):
32733 
    return not (self == other)
32734 
 
7169 anupam.sin 32735 
class getRechargeTransactionsByNumber_args:
32736 
  """
32737 
  Attributes:
32738 
   - number
7172 anupam.sin 32739 
   - storeId
7169 anupam.sin 32740 
  """
32741 
 
32742 
  thrift_spec = (
32743 
    None, # 0
32744 
    (1, TType.STRING, 'number', None, None, ), # 1
7172 anupam.sin 32745 
    (2, TType.I64, 'storeId', None, None, ), # 2
7169 anupam.sin 32746 
  )
32747 
 
7172 anupam.sin 32748 
  def __init__(self, number=None, storeId=None,):
7169 anupam.sin 32749 
    self.number = number
7172 anupam.sin 32750 
    self.storeId = storeId
7169 anupam.sin 32751 
 
32752 
  def read(self, iprot):
32753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32755 
      return
32756 
    iprot.readStructBegin()
32757 
    while True:
32758 
      (fname, ftype, fid) = iprot.readFieldBegin()
32759 
      if ftype == TType.STOP:
32760 
        break
32761 
      if fid == 1:
32762 
        if ftype == TType.STRING:
32763 
          self.number = iprot.readString();
32764 
        else:
32765 
          iprot.skip(ftype)
7172 anupam.sin 32766 
      elif fid == 2:
32767 
        if ftype == TType.I64:
32768 
          self.storeId = iprot.readI64();
32769 
        else:
32770 
          iprot.skip(ftype)
7169 anupam.sin 32771 
      else:
32772 
        iprot.skip(ftype)
32773 
      iprot.readFieldEnd()
32774 
    iprot.readStructEnd()
32775 
 
32776 
  def write(self, oprot):
32777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32779 
      return
32780 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_args')
32781 
    if self.number is not None:
32782 
      oprot.writeFieldBegin('number', TType.STRING, 1)
32783 
      oprot.writeString(self.number)
32784 
      oprot.writeFieldEnd()
7172 anupam.sin 32785 
    if self.storeId is not None:
32786 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
32787 
      oprot.writeI64(self.storeId)
32788 
      oprot.writeFieldEnd()
7169 anupam.sin 32789 
    oprot.writeFieldStop()
32790 
    oprot.writeStructEnd()
32791 
 
32792 
  def validate(self):
32793 
    return
32794 
 
32795 
 
32796 
  def __repr__(self):
32797 
    L = ['%s=%r' % (key, value)
32798 
      for key, value in self.__dict__.iteritems()]
32799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32800 
 
32801 
  def __eq__(self, other):
32802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32803 
 
32804 
  def __ne__(self, other):
32805 
    return not (self == other)
32806 
 
32807 
class getRechargeTransactionsByNumber_result:
32808 
  """
32809 
  Attributes:
32810 
   - success
32811 
  """
32812 
 
32813 
  thrift_spec = (
32814 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32815 
  )
32816 
 
32817 
  def __init__(self, success=None,):
32818 
    self.success = success
32819 
 
32820 
  def read(self, iprot):
32821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32823 
      return
32824 
    iprot.readStructBegin()
32825 
    while True:
32826 
      (fname, ftype, fid) = iprot.readFieldBegin()
32827 
      if ftype == TType.STOP:
32828 
        break
32829 
      if fid == 0:
32830 
        if ftype == TType.LIST:
32831 
          self.success = []
32832 
          (_etype761, _size758) = iprot.readListBegin()
32833 
          for _i762 in xrange(_size758):
32834 
            _elem763 = RechargeTransaction()
32835 
            _elem763.read(iprot)
32836 
            self.success.append(_elem763)
32837 
          iprot.readListEnd()
32838 
        else:
32839 
          iprot.skip(ftype)
32840 
      else:
32841 
        iprot.skip(ftype)
32842 
      iprot.readFieldEnd()
32843 
    iprot.readStructEnd()
32844 
 
32845 
  def write(self, oprot):
32846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32848 
      return
32849 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
32850 
    if self.success is not None:
32851 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32852 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32853 
      for iter764 in self.success:
32854 
        iter764.write(oprot)
32855 
      oprot.writeListEnd()
32856 
      oprot.writeFieldEnd()
32857 
    oprot.writeFieldStop()
32858 
    oprot.writeStructEnd()
32859 
 
32860 
  def validate(self):
32861 
    return
32862 
 
32863 
 
32864 
  def __repr__(self):
32865 
    L = ['%s=%r' % (key, value)
32866 
      for key, value in self.__dict__.iteritems()]
32867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32868 
 
32869 
  def __eq__(self, other):
32870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32871 
 
32872 
  def __ne__(self, other):
32873 
    return not (self == other)
32874 
 
32875 
class updateHotspotStorePassword_args:
32876 
  """
32877 
  Attributes:
32878 
   - storeId
32879 
   - password
32880 
  """
32881 
 
32882 
  thrift_spec = (
32883 
    None, # 0
32884 
    (1, TType.I64, 'storeId', None, None, ), # 1
32885 
    (2, TType.STRING, 'password', None, None, ), # 2
32886 
  )
32887 
 
32888 
  def __init__(self, storeId=None, password=None,):
32889 
    self.storeId = storeId
32890 
    self.password = password
32891 
 
32892 
  def read(self, iprot):
32893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32895 
      return
32896 
    iprot.readStructBegin()
32897 
    while True:
32898 
      (fname, ftype, fid) = iprot.readFieldBegin()
32899 
      if ftype == TType.STOP:
32900 
        break
32901 
      if fid == 1:
32902 
        if ftype == TType.I64:
32903 
          self.storeId = iprot.readI64();
32904 
        else:
32905 
          iprot.skip(ftype)
32906 
      elif fid == 2:
32907 
        if ftype == TType.STRING:
32908 
          self.password = iprot.readString();
32909 
        else:
32910 
          iprot.skip(ftype)
32911 
      else:
32912 
        iprot.skip(ftype)
32913 
      iprot.readFieldEnd()
32914 
    iprot.readStructEnd()
32915 
 
32916 
  def write(self, oprot):
32917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32919 
      return
32920 
    oprot.writeStructBegin('updateHotspotStorePassword_args')
32921 
    if self.storeId is not None:
32922 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
32923 
      oprot.writeI64(self.storeId)
32924 
      oprot.writeFieldEnd()
32925 
    if self.password is not None:
32926 
      oprot.writeFieldBegin('password', TType.STRING, 2)
32927 
      oprot.writeString(self.password)
32928 
      oprot.writeFieldEnd()
32929 
    oprot.writeFieldStop()
32930 
    oprot.writeStructEnd()
32931 
 
32932 
  def validate(self):
32933 
    return
32934 
 
32935 
 
32936 
  def __repr__(self):
32937 
    L = ['%s=%r' % (key, value)
32938 
      for key, value in self.__dict__.iteritems()]
32939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32940 
 
32941 
  def __eq__(self, other):
32942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32943 
 
32944 
  def __ne__(self, other):
32945 
    return not (self == other)
32946 
 
32947 
class updateHotspotStorePassword_result:
32948 
  """
32949 
  Attributes:
32950 
   - success
32951 
  """
32952 
 
32953 
  thrift_spec = (
32954 
    (0, TType.BOOL, 'success', None, None, ), # 0
32955 
  )
32956 
 
32957 
  def __init__(self, success=None,):
32958 
    self.success = success
32959 
 
32960 
  def read(self, iprot):
32961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32963 
      return
32964 
    iprot.readStructBegin()
32965 
    while True:
32966 
      (fname, ftype, fid) = iprot.readFieldBegin()
32967 
      if ftype == TType.STOP:
32968 
        break
32969 
      if fid == 0:
32970 
        if ftype == TType.BOOL:
32971 
          self.success = iprot.readBool();
32972 
        else:
32973 
          iprot.skip(ftype)
32974 
      else:
32975 
        iprot.skip(ftype)
32976 
      iprot.readFieldEnd()
32977 
    iprot.readStructEnd()
32978 
 
32979 
  def write(self, oprot):
32980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32982 
      return
32983 
    oprot.writeStructBegin('updateHotspotStorePassword_result')
32984 
    if self.success is not None:
32985 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32986 
      oprot.writeBool(self.success)
32987 
      oprot.writeFieldEnd()
32988 
    oprot.writeFieldStop()
32989 
    oprot.writeStructEnd()
32990 
 
32991 
  def validate(self):
32992 
    return
32993 
 
32994 
 
32995 
  def __repr__(self):
32996 
    L = ['%s=%r' % (key, value)
32997 
      for key, value in self.__dict__.iteritems()]
32998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32999 
 
33000 
  def __eq__(self, other):
33001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33002 
 
33003 
  def __ne__(self, other):
33004 
    return not (self == other)
7263 anupam.sin 33005 
 
7285 rajveer 33006 
class topupCompanyWallet_args:
7263 anupam.sin 33007 
  """
33008 
  Attributes:
7285 rajveer 33009 
   - companyId
33010 
   - amount
7263 anupam.sin 33011 
  """
33012 
 
33013 
  thrift_spec = (
33014 
    None, # 0
7285 rajveer 33015 
    (1, TType.I64, 'companyId', None, None, ), # 1
33016 
    (2, TType.I64, 'amount', None, None, ), # 2
7263 anupam.sin 33017 
  )
33018 
 
7285 rajveer 33019 
  def __init__(self, companyId=None, amount=None,):
33020 
    self.companyId = companyId
33021 
    self.amount = amount
7263 anupam.sin 33022 
 
33023 
  def read(self, iprot):
33024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33026 
      return
33027 
    iprot.readStructBegin()
33028 
    while True:
33029 
      (fname, ftype, fid) = iprot.readFieldBegin()
33030 
      if ftype == TType.STOP:
33031 
        break
33032 
      if fid == 1:
33033 
        if ftype == TType.I64:
7285 rajveer 33034 
          self.companyId = iprot.readI64();
7263 anupam.sin 33035 
        else:
33036 
          iprot.skip(ftype)
7285 rajveer 33037 
      elif fid == 2:
33038 
        if ftype == TType.I64:
33039 
          self.amount = iprot.readI64();
33040 
        else:
33041 
          iprot.skip(ftype)
7263 anupam.sin 33042 
      else:
33043 
        iprot.skip(ftype)
33044 
      iprot.readFieldEnd()
33045 
    iprot.readStructEnd()
33046 
 
33047 
  def write(self, oprot):
33048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33050 
      return
7285 rajveer 33051 
    oprot.writeStructBegin('topupCompanyWallet_args')
33052 
    if self.companyId is not None:
33053 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
33054 
      oprot.writeI64(self.companyId)
7263 anupam.sin 33055 
      oprot.writeFieldEnd()
7285 rajveer 33056 
    if self.amount is not None:
33057 
      oprot.writeFieldBegin('amount', TType.I64, 2)
33058 
      oprot.writeI64(self.amount)
33059 
      oprot.writeFieldEnd()
7263 anupam.sin 33060 
    oprot.writeFieldStop()
33061 
    oprot.writeStructEnd()
33062 
 
33063 
  def validate(self):
33064 
    return
33065 
 
33066 
 
33067 
  def __repr__(self):
33068 
    L = ['%s=%r' % (key, value)
33069 
      for key, value in self.__dict__.iteritems()]
33070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33071 
 
33072 
  def __eq__(self, other):
33073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33074 
 
33075 
  def __ne__(self, other):
33076 
    return not (self == other)
33077 
 
7285 rajveer 33078 
class topupCompanyWallet_result:
7263 anupam.sin 33079 
  """
33080 
  Attributes:
33081 
   - success
33082 
  """
33083 
 
33084 
  thrift_spec = (
7285 rajveer 33085 
    (0, TType.I64, 'success', None, None, ), # 0
7263 anupam.sin 33086 
  )
33087 
 
33088 
  def __init__(self, success=None,):
33089 
    self.success = success
33090 
 
33091 
  def read(self, iprot):
33092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33094 
      return
33095 
    iprot.readStructBegin()
33096 
    while True:
33097 
      (fname, ftype, fid) = iprot.readFieldBegin()
33098 
      if ftype == TType.STOP:
33099 
        break
33100 
      if fid == 0:
7285 rajveer 33101 
        if ftype == TType.I64:
33102 
          self.success = iprot.readI64();
7263 anupam.sin 33103 
        else:
33104 
          iprot.skip(ftype)
33105 
      else:
33106 
        iprot.skip(ftype)
33107 
      iprot.readFieldEnd()
33108 
    iprot.readStructEnd()
33109 
 
33110 
  def write(self, oprot):
33111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33113 
      return
7285 rajveer 33114 
    oprot.writeStructBegin('topupCompanyWallet_result')
7263 anupam.sin 33115 
    if self.success is not None:
7285 rajveer 33116 
      oprot.writeFieldBegin('success', TType.I64, 0)
33117 
      oprot.writeI64(self.success)
7263 anupam.sin 33118 
      oprot.writeFieldEnd()
33119 
    oprot.writeFieldStop()
33120 
    oprot.writeStructEnd()
33121 
 
33122 
  def validate(self):
33123 
    return
33124 
 
33125 
 
33126 
  def __repr__(self):
33127 
    L = ['%s=%r' % (key, value)
33128 
      for key, value in self.__dict__.iteritems()]
33129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33130 
 
33131 
  def __eq__(self, other):
33132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33133 
 
33134 
  def __ne__(self, other):
33135 
    return not (self == other)
7267 anupam.sin 33136 
 
7285 rajveer 33137 
class getWalletBalanceForCompany_args:
33138 
  """
33139 
  Attributes:
33140 
   - companyId
33141 
  """
7267 anupam.sin 33142 
 
33143 
  thrift_spec = (
7285 rajveer 33144 
    None, # 0
33145 
    (1, TType.I64, 'companyId', None, None, ), # 1
7267 anupam.sin 33146 
  )
33147 
 
7285 rajveer 33148 
  def __init__(self, companyId=None,):
33149 
    self.companyId = companyId
33150 
 
7267 anupam.sin 33151 
  def read(self, iprot):
33152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33154 
      return
33155 
    iprot.readStructBegin()
33156 
    while True:
33157 
      (fname, ftype, fid) = iprot.readFieldBegin()
33158 
      if ftype == TType.STOP:
33159 
        break
7285 rajveer 33160 
      if fid == 1:
33161 
        if ftype == TType.I64:
33162 
          self.companyId = iprot.readI64();
33163 
        else:
33164 
          iprot.skip(ftype)
7267 anupam.sin 33165 
      else:
33166 
        iprot.skip(ftype)
33167 
      iprot.readFieldEnd()
33168 
    iprot.readStructEnd()
33169 
 
33170 
  def write(self, oprot):
33171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33173 
      return
7285 rajveer 33174 
    oprot.writeStructBegin('getWalletBalanceForCompany_args')
33175 
    if self.companyId is not None:
33176 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
33177 
      oprot.writeI64(self.companyId)
33178 
      oprot.writeFieldEnd()
7267 anupam.sin 33179 
    oprot.writeFieldStop()
33180 
    oprot.writeStructEnd()
33181 
 
33182 
  def validate(self):
33183 
    return
33184 
 
33185 
 
33186 
  def __repr__(self):
33187 
    L = ['%s=%r' % (key, value)
33188 
      for key, value in self.__dict__.iteritems()]
33189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33190 
 
33191 
  def __eq__(self, other):
33192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33193 
 
33194 
  def __ne__(self, other):
33195 
    return not (self == other)
33196 
 
7285 rajveer 33197 
class getWalletBalanceForCompany_result:
7267 anupam.sin 33198 
  """
33199 
  Attributes:
33200 
   - success
33201 
  """
33202 
 
33203 
  thrift_spec = (
7285 rajveer 33204 
    (0, TType.I64, 'success', None, None, ), # 0
7267 anupam.sin 33205 
  )
33206 
 
33207 
  def __init__(self, success=None,):
33208 
    self.success = success
33209 
 
33210 
  def read(self, iprot):
33211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33213 
      return
33214 
    iprot.readStructBegin()
33215 
    while True:
33216 
      (fname, ftype, fid) = iprot.readFieldBegin()
33217 
      if ftype == TType.STOP:
33218 
        break
33219 
      if fid == 0:
7285 rajveer 33220 
        if ftype == TType.I64:
33221 
          self.success = iprot.readI64();
7267 anupam.sin 33222 
        else:
33223 
          iprot.skip(ftype)
33224 
      else:
33225 
        iprot.skip(ftype)
33226 
      iprot.readFieldEnd()
33227 
    iprot.readStructEnd()
33228 
 
33229 
  def write(self, oprot):
33230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33232 
      return
7285 rajveer 33233 
    oprot.writeStructBegin('getWalletBalanceForCompany_result')
7267 anupam.sin 33234 
    if self.success is not None:
7285 rajveer 33235 
      oprot.writeFieldBegin('success', TType.I64, 0)
33236 
      oprot.writeI64(self.success)
7267 anupam.sin 33237 
      oprot.writeFieldEnd()
33238 
    oprot.writeFieldStop()
33239 
    oprot.writeStructEnd()
33240 
 
33241 
  def validate(self):
33242 
    return
33243 
 
33244 
 
33245 
  def __repr__(self):
33246 
    L = ['%s=%r' % (key, value)
33247 
      for key, value in self.__dict__.iteritems()]
33248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33249 
 
33250 
  def __eq__(self, other):
33251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33252 
 
33253 
  def __ne__(self, other):
33254 
    return not (self == other)
33255 
 
7285 rajveer 33256 
class getSourceDetail_args:
7267 anupam.sin 33257 
  """
33258 
  Attributes:
7285 rajveer 33259 
   - source
7267 anupam.sin 33260 
  """
33261 
 
33262 
  thrift_spec = (
33263 
    None, # 0
7285 rajveer 33264 
    (1, TType.I64, 'source', None, None, ), # 1
7267 anupam.sin 33265 
  )
33266 
 
7285 rajveer 33267 
  def __init__(self, source=None,):
33268 
    self.source = source
7267 anupam.sin 33269 
 
33270 
  def read(self, iprot):
33271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33273 
      return
33274 
    iprot.readStructBegin()
33275 
    while True:
33276 
      (fname, ftype, fid) = iprot.readFieldBegin()
33277 
      if ftype == TType.STOP:
33278 
        break
33279 
      if fid == 1:
7285 rajveer 33280 
        if ftype == TType.I64:
33281 
          self.source = iprot.readI64();
7267 anupam.sin 33282 
        else:
33283 
          iprot.skip(ftype)
33284 
      else:
33285 
        iprot.skip(ftype)
33286 
      iprot.readFieldEnd()
33287 
    iprot.readStructEnd()
33288 
 
33289 
  def write(self, oprot):
33290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33292 
      return
7285 rajveer 33293 
    oprot.writeStructBegin('getSourceDetail_args')
33294 
    if self.source is not None:
33295 
      oprot.writeFieldBegin('source', TType.I64, 1)
33296 
      oprot.writeI64(self.source)
7267 anupam.sin 33297 
      oprot.writeFieldEnd()
33298 
    oprot.writeFieldStop()
33299 
    oprot.writeStructEnd()
33300 
 
33301 
  def validate(self):
33302 
    return
33303 
 
33304 
 
33305 
  def __repr__(self):
33306 
    L = ['%s=%r' % (key, value)
33307 
      for key, value in self.__dict__.iteritems()]
33308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33309 
 
33310 
  def __eq__(self, other):
33311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33312 
 
33313 
  def __ne__(self, other):
33314 
    return not (self == other)
33315 
 
7285 rajveer 33316 
class getSourceDetail_result:
7267 anupam.sin 33317 
  """
33318 
  Attributes:
33319 
   - success
33320 
  """
33321 
 
33322 
  thrift_spec = (
7285 rajveer 33323 
    (0, TType.STRUCT, 'success', (SourceDetail, SourceDetail.thrift_spec), None, ), # 0
7267 anupam.sin 33324 
  )
33325 
 
33326 
  def __init__(self, success=None,):
33327 
    self.success = success
33328 
 
33329 
  def read(self, iprot):
33330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33332 
      return
33333 
    iprot.readStructBegin()
33334 
    while True:
33335 
      (fname, ftype, fid) = iprot.readFieldBegin()
33336 
      if ftype == TType.STOP:
33337 
        break
33338 
      if fid == 0:
7285 rajveer 33339 
        if ftype == TType.STRUCT:
33340 
          self.success = SourceDetail()
33341 
          self.success.read(iprot)
7267 anupam.sin 33342 
        else:
33343 
          iprot.skip(ftype)
33344 
      else:
33345 
        iprot.skip(ftype)
33346 
      iprot.readFieldEnd()
33347 
    iprot.readStructEnd()
33348 
 
33349 
  def write(self, oprot):
33350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33352 
      return
7285 rajveer 33353 
    oprot.writeStructBegin('getSourceDetail_result')
7267 anupam.sin 33354 
    if self.success is not None:
7285 rajveer 33355 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33356 
      self.success.write(oprot)
7267 anupam.sin 33357 
      oprot.writeFieldEnd()
33358 
    oprot.writeFieldStop()
33359 
    oprot.writeStructEnd()
33360 
 
33361 
  def validate(self):
33362 
    return
33363 
 
33364 
 
33365 
  def __repr__(self):
33366 
    L = ['%s=%r' % (key, value)
33367 
      for key, value in self.__dict__.iteritems()]
33368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33369 
 
33370 
  def __eq__(self, other):
33371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33372 
 
33373 
  def __ne__(self, other):
33374 
    return not (self == other)
7308 rajveer 33375 
 
33376 
class getAllCircles_args:
33377 
 
33378 
  thrift_spec = (
33379 
  )
33380 
 
33381 
  def read(self, iprot):
33382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33384 
      return
33385 
    iprot.readStructBegin()
33386 
    while True:
33387 
      (fname, ftype, fid) = iprot.readFieldBegin()
33388 
      if ftype == TType.STOP:
33389 
        break
33390 
      else:
33391 
        iprot.skip(ftype)
33392 
      iprot.readFieldEnd()
33393 
    iprot.readStructEnd()
33394 
 
33395 
  def write(self, oprot):
33396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33398 
      return
33399 
    oprot.writeStructBegin('getAllCircles_args')
33400 
    oprot.writeFieldStop()
33401 
    oprot.writeStructEnd()
33402 
 
33403 
  def validate(self):
33404 
    return
33405 
 
33406 
 
33407 
  def __repr__(self):
33408 
    L = ['%s=%r' % (key, value)
33409 
      for key, value in self.__dict__.iteritems()]
33410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33411 
 
33412 
  def __eq__(self, other):
33413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33414 
 
33415 
  def __ne__(self, other):
33416 
    return not (self == other)
33417 
 
33418 
class getAllCircles_result:
33419 
  """
33420 
  Attributes:
33421 
   - success
33422 
  """
33423 
 
33424 
  thrift_spec = (
33425 
    (0, TType.LIST, 'success', (TType.STRUCT,(TelecomCircle, TelecomCircle.thrift_spec)), None, ), # 0
33426 
  )
33427 
 
33428 
  def __init__(self, success=None,):
33429 
    self.success = success
33430 
 
33431 
  def read(self, iprot):
33432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33434 
      return
33435 
    iprot.readStructBegin()
33436 
    while True:
33437 
      (fname, ftype, fid) = iprot.readFieldBegin()
33438 
      if ftype == TType.STOP:
33439 
        break
33440 
      if fid == 0:
33441 
        if ftype == TType.LIST:
33442 
          self.success = []
33443 
          (_etype768, _size765) = iprot.readListBegin()
33444 
          for _i769 in xrange(_size765):
33445 
            _elem770 = TelecomCircle()
33446 
            _elem770.read(iprot)
33447 
            self.success.append(_elem770)
33448 
          iprot.readListEnd()
33449 
        else:
33450 
          iprot.skip(ftype)
33451 
      else:
33452 
        iprot.skip(ftype)
33453 
      iprot.readFieldEnd()
33454 
    iprot.readStructEnd()
33455 
 
33456 
  def write(self, oprot):
33457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33459 
      return
33460 
    oprot.writeStructBegin('getAllCircles_result')
33461 
    if self.success is not None:
33462 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33463 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
33464 
      for iter771 in self.success:
33465 
        iter771.write(oprot)
33466 
      oprot.writeListEnd()
33467 
      oprot.writeFieldEnd()
33468 
    oprot.writeFieldStop()
33469 
    oprot.writeStructEnd()
33470 
 
33471 
  def validate(self):
33472 
    return
33473 
 
33474 
 
33475 
  def __repr__(self):
33476 
    L = ['%s=%r' % (key, value)
33477 
      for key, value in self.__dict__.iteritems()]
33478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33479 
 
33480 
  def __eq__(self, other):
33481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33482 
 
33483 
  def __ne__(self, other):
33484 
    return not (self == other)
33485 
 
33486 
class deleteFrcs_args:
33487 
  """
33488 
  Attributes:
33489 
   - frcIdsToDelete
33490 
  """
33491 
 
33492 
  thrift_spec = (
33493 
    None, # 0
33494 
    (1, TType.LIST, 'frcIdsToDelete', (TType.I64,None), None, ), # 1
33495 
  )
33496 
 
33497 
  def __init__(self, frcIdsToDelete=None,):
33498 
    self.frcIdsToDelete = frcIdsToDelete
33499 
 
33500 
  def read(self, iprot):
33501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33503 
      return
33504 
    iprot.readStructBegin()
33505 
    while True:
33506 
      (fname, ftype, fid) = iprot.readFieldBegin()
33507 
      if ftype == TType.STOP:
33508 
        break
33509 
      if fid == 1:
33510 
        if ftype == TType.LIST:
33511 
          self.frcIdsToDelete = []
33512 
          (_etype775, _size772) = iprot.readListBegin()
33513 
          for _i776 in xrange(_size772):
33514 
            _elem777 = iprot.readI64();
33515 
            self.frcIdsToDelete.append(_elem777)
33516 
          iprot.readListEnd()
33517 
        else:
33518 
          iprot.skip(ftype)
33519 
      else:
33520 
        iprot.skip(ftype)
33521 
      iprot.readFieldEnd()
33522 
    iprot.readStructEnd()
33523 
 
33524 
  def write(self, oprot):
33525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33527 
      return
33528 
    oprot.writeStructBegin('deleteFrcs_args')
33529 
    if self.frcIdsToDelete is not None:
33530 
      oprot.writeFieldBegin('frcIdsToDelete', TType.LIST, 1)
33531 
      oprot.writeListBegin(TType.I64, len(self.frcIdsToDelete))
33532 
      for iter778 in self.frcIdsToDelete:
33533 
        oprot.writeI64(iter778)
33534 
      oprot.writeListEnd()
33535 
      oprot.writeFieldEnd()
33536 
    oprot.writeFieldStop()
33537 
    oprot.writeStructEnd()
33538 
 
33539 
  def validate(self):
33540 
    return
33541 
 
33542 
 
33543 
  def __repr__(self):
33544 
    L = ['%s=%r' % (key, value)
33545 
      for key, value in self.__dict__.iteritems()]
33546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33547 
 
33548 
  def __eq__(self, other):
33549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33550 
 
33551 
  def __ne__(self, other):
33552 
    return not (self == other)
33553 
 
33554 
class deleteFrcs_result:
33555 
  """
33556 
  Attributes:
33557 
   - success
33558 
  """
33559 
 
33560 
  thrift_spec = (
33561 
    (0, TType.BOOL, 'success', None, None, ), # 0
33562 
  )
33563 
 
33564 
  def __init__(self, success=None,):
33565 
    self.success = success
33566 
 
33567 
  def read(self, iprot):
33568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33570 
      return
33571 
    iprot.readStructBegin()
33572 
    while True:
33573 
      (fname, ftype, fid) = iprot.readFieldBegin()
33574 
      if ftype == TType.STOP:
33575 
        break
33576 
      if fid == 0:
33577 
        if ftype == TType.BOOL:
33578 
          self.success = iprot.readBool();
33579 
        else:
33580 
          iprot.skip(ftype)
33581 
      else:
33582 
        iprot.skip(ftype)
33583 
      iprot.readFieldEnd()
33584 
    iprot.readStructEnd()
33585 
 
33586 
  def write(self, oprot):
33587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33589 
      return
33590 
    oprot.writeStructBegin('deleteFrcs_result')
33591 
    if self.success is not None:
33592 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
33593 
      oprot.writeBool(self.success)
33594 
      oprot.writeFieldEnd()
33595 
    oprot.writeFieldStop()
33596 
    oprot.writeStructEnd()
33597 
 
33598 
  def validate(self):
33599 
    return
33600 
 
33601 
 
33602 
  def __repr__(self):
33603 
    L = ['%s=%r' % (key, value)
33604 
      for key, value in self.__dict__.iteritems()]
33605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33606 
 
33607 
  def __eq__(self, other):
33608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33609 
 
33610 
  def __ne__(self, other):
33611 
    return not (self == other)
7311 kshitij.so 33612 
 
33613 
class addAmazonOrder_args:
33614 
  """
33615 
  Attributes:
33616 
   - amazonOrder
33617 
  """
33618 
 
33619 
  thrift_spec = (
33620 
    None, # 0
33621 
    (1, TType.STRUCT, 'amazonOrder', (AmazonOrder, AmazonOrder.thrift_spec), None, ), # 1
33622 
  )
33623 
 
33624 
  def __init__(self, amazonOrder=None,):
33625 
    self.amazonOrder = amazonOrder
33626 
 
33627 
  def read(self, iprot):
33628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33630 
      return
33631 
    iprot.readStructBegin()
33632 
    while True:
33633 
      (fname, ftype, fid) = iprot.readFieldBegin()
33634 
      if ftype == TType.STOP:
33635 
        break
33636 
      if fid == 1:
33637 
        if ftype == TType.STRUCT:
33638 
          self.amazonOrder = AmazonOrder()
33639 
          self.amazonOrder.read(iprot)
33640 
        else:
33641 
          iprot.skip(ftype)
33642 
      else:
33643 
        iprot.skip(ftype)
33644 
      iprot.readFieldEnd()
33645 
    iprot.readStructEnd()
33646 
 
33647 
  def write(self, oprot):
33648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33650 
      return
33651 
    oprot.writeStructBegin('addAmazonOrder_args')
33652 
    if self.amazonOrder is not None:
33653 
      oprot.writeFieldBegin('amazonOrder', TType.STRUCT, 1)
33654 
      self.amazonOrder.write(oprot)
33655 
      oprot.writeFieldEnd()
33656 
    oprot.writeFieldStop()
33657 
    oprot.writeStructEnd()
33658 
 
33659 
  def validate(self):
33660 
    return
33661 
 
33662 
 
33663 
  def __repr__(self):
33664 
    L = ['%s=%r' % (key, value)
33665 
      for key, value in self.__dict__.iteritems()]
33666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33667 
 
33668 
  def __eq__(self, other):
33669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33670 
 
33671 
  def __ne__(self, other):
33672 
    return not (self == other)
33673 
 
33674 
class addAmazonOrder_result:
33675 
 
33676 
  thrift_spec = (
33677 
  )
33678 
 
33679 
  def read(self, iprot):
33680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33682 
      return
33683 
    iprot.readStructBegin()
33684 
    while True:
33685 
      (fname, ftype, fid) = iprot.readFieldBegin()
33686 
      if ftype == TType.STOP:
33687 
        break
33688 
      else:
33689 
        iprot.skip(ftype)
33690 
      iprot.readFieldEnd()
33691 
    iprot.readStructEnd()
33692 
 
33693 
  def write(self, oprot):
33694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33696 
      return
33697 
    oprot.writeStructBegin('addAmazonOrder_result')
33698 
    oprot.writeFieldStop()
33699 
    oprot.writeStructEnd()
33700 
 
33701 
  def validate(self):
33702 
    return
33703 
 
33704 
 
33705 
  def __repr__(self):
33706 
    L = ['%s=%r' % (key, value)
33707 
      for key, value in self.__dict__.iteritems()]
33708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33709 
 
33710 
  def __eq__(self, other):
33711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33712 
 
33713 
  def __ne__(self, other):
33714 
    return not (self == other)
33715 
 
7322 vikram.rag 33716 
class updateAmazonOrderStatus_args:
7311 kshitij.so 33717 
  """
33718 
  Attributes:
33719 
   - orderId
33720 
   - status
33721 
  """
33722 
 
33723 
  thrift_spec = (
33724 
    None, # 0
33725 
    (1, TType.I64, 'orderId', None, None, ), # 1
33726 
    (2, TType.STRING, 'status', None, None, ), # 2
33727 
  )
33728 
 
33729 
  def __init__(self, orderId=None, status=None,):
33730 
    self.orderId = orderId
33731 
    self.status = status
33732 
 
33733 
  def read(self, iprot):
33734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33736 
      return
33737 
    iprot.readStructBegin()
33738 
    while True:
33739 
      (fname, ftype, fid) = iprot.readFieldBegin()
33740 
      if ftype == TType.STOP:
33741 
        break
33742 
      if fid == 1:
33743 
        if ftype == TType.I64:
33744 
          self.orderId = iprot.readI64();
33745 
        else:
33746 
          iprot.skip(ftype)
33747 
      elif fid == 2:
33748 
        if ftype == TType.STRING:
33749 
          self.status = iprot.readString();
33750 
        else:
33751 
          iprot.skip(ftype)
33752 
      else:
33753 
        iprot.skip(ftype)
33754 
      iprot.readFieldEnd()
33755 
    iprot.readStructEnd()
33756 
 
33757 
  def write(self, oprot):
33758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33760 
      return
7322 vikram.rag 33761 
    oprot.writeStructBegin('updateAmazonOrderStatus_args')
7311 kshitij.so 33762 
    if self.orderId is not None:
33763 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
33764 
      oprot.writeI64(self.orderId)
33765 
      oprot.writeFieldEnd()
33766 
    if self.status is not None:
33767 
      oprot.writeFieldBegin('status', TType.STRING, 2)
33768 
      oprot.writeString(self.status)
33769 
      oprot.writeFieldEnd()
33770 
    oprot.writeFieldStop()
33771 
    oprot.writeStructEnd()
33772 
 
33773 
  def validate(self):
33774 
    return
33775 
 
33776 
 
33777 
  def __repr__(self):
33778 
    L = ['%s=%r' % (key, value)
33779 
      for key, value in self.__dict__.iteritems()]
33780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33781 
 
33782 
  def __eq__(self, other):
33783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33784 
 
33785 
  def __ne__(self, other):
33786 
    return not (self == other)
33787 
 
7322 vikram.rag 33788 
class updateAmazonOrderStatus_result:
7311 kshitij.so 33789 
  """
33790 
  Attributes:
33791 
   - success
33792 
  """
33793 
 
33794 
  thrift_spec = (
33795 
    (0, TType.BOOL, 'success', None, None, ), # 0
33796 
  )
33797 
 
33798 
  def __init__(self, success=None,):
33799 
    self.success = success
33800 
 
33801 
  def read(self, iprot):
33802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33804 
      return
33805 
    iprot.readStructBegin()
33806 
    while True:
33807 
      (fname, ftype, fid) = iprot.readFieldBegin()
33808 
      if ftype == TType.STOP:
33809 
        break
33810 
      if fid == 0:
33811 
        if ftype == TType.BOOL:
33812 
          self.success = iprot.readBool();
33813 
        else:
33814 
          iprot.skip(ftype)
33815 
      else:
33816 
        iprot.skip(ftype)
33817 
      iprot.readFieldEnd()
33818 
    iprot.readStructEnd()
33819 
 
33820 
  def write(self, oprot):
33821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33823 
      return
7322 vikram.rag 33824 
    oprot.writeStructBegin('updateAmazonOrderStatus_result')
7311 kshitij.so 33825 
    if self.success is not None:
33826 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
33827 
      oprot.writeBool(self.success)
33828 
      oprot.writeFieldEnd()
33829 
    oprot.writeFieldStop()
33830 
    oprot.writeStructEnd()
33831 
 
33832 
  def validate(self):
33833 
    return
33834 
 
33835 
 
33836 
  def __repr__(self):
33837 
    L = ['%s=%r' % (key, value)
33838 
      for key, value in self.__dict__.iteritems()]
33839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33840 
 
33841 
  def __eq__(self, other):
33842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33843 
 
33844 
  def __ne__(self, other):
33845 
    return not (self == other)
33846 
 
33847 
class getAmazonOrdersShipped_args:
33848 
  """
33849 
  Attributes:
33850 
   - interval
33851 
  """
33852 
 
33853 
  thrift_spec = (
33854 
    None, # 0
33855 
    (1, TType.I64, 'interval', None, None, ), # 1
33856 
  )
33857 
 
33858 
  def __init__(self, interval=None,):
33859 
    self.interval = interval
33860 
 
33861 
  def read(self, iprot):
33862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33864 
      return
33865 
    iprot.readStructBegin()
33866 
    while True:
33867 
      (fname, ftype, fid) = iprot.readFieldBegin()
33868 
      if ftype == TType.STOP:
33869 
        break
33870 
      if fid == 1:
33871 
        if ftype == TType.I64:
33872 
          self.interval = iprot.readI64();
33873 
        else:
33874 
          iprot.skip(ftype)
33875 
      else:
33876 
        iprot.skip(ftype)
33877 
      iprot.readFieldEnd()
33878 
    iprot.readStructEnd()
33879 
 
33880 
  def write(self, oprot):
33881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33883 
      return
33884 
    oprot.writeStructBegin('getAmazonOrdersShipped_args')
33885 
    if self.interval is not None:
33886 
      oprot.writeFieldBegin('interval', TType.I64, 1)
33887 
      oprot.writeI64(self.interval)
33888 
      oprot.writeFieldEnd()
33889 
    oprot.writeFieldStop()
33890 
    oprot.writeStructEnd()
33891 
 
33892 
  def validate(self):
33893 
    return
33894 
 
33895 
 
33896 
  def __repr__(self):
33897 
    L = ['%s=%r' % (key, value)
33898 
      for key, value in self.__dict__.iteritems()]
33899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33900 
 
33901 
  def __eq__(self, other):
33902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33903 
 
33904 
  def __ne__(self, other):
33905 
    return not (self == other)
33906 
 
33907 
class getAmazonOrdersShipped_result:
33908 
  """
33909 
  Attributes:
33910 
   - success
33911 
  """
33912 
 
33913 
  thrift_spec = (
33914 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
33915 
  )
33916 
 
33917 
  def __init__(self, success=None,):
33918 
    self.success = success
33919 
 
33920 
  def read(self, iprot):
33921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33923 
      return
33924 
    iprot.readStructBegin()
33925 
    while True:
33926 
      (fname, ftype, fid) = iprot.readFieldBegin()
33927 
      if ftype == TType.STOP:
33928 
        break
33929 
      if fid == 0:
33930 
        if ftype == TType.LIST:
33931 
          self.success = []
33932 
          (_etype782, _size779) = iprot.readListBegin()
33933 
          for _i783 in xrange(_size779):
33934 
            _elem784 = Order()
33935 
            _elem784.read(iprot)
33936 
            self.success.append(_elem784)
33937 
          iprot.readListEnd()
33938 
        else:
33939 
          iprot.skip(ftype)
33940 
      else:
33941 
        iprot.skip(ftype)
33942 
      iprot.readFieldEnd()
33943 
    iprot.readStructEnd()
33944 
 
33945 
  def write(self, oprot):
33946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33948 
      return
33949 
    oprot.writeStructBegin('getAmazonOrdersShipped_result')
33950 
    if self.success is not None:
33951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
33953 
      for iter785 in self.success:
33954 
        iter785.write(oprot)
33955 
      oprot.writeListEnd()
33956 
      oprot.writeFieldEnd()
33957 
    oprot.writeFieldStop()
33958 
    oprot.writeStructEnd()
33959 
 
33960 
  def validate(self):
33961 
    return
33962 
 
33963 
 
33964 
  def __repr__(self):
33965 
    L = ['%s=%r' % (key, value)
33966 
      for key, value in self.__dict__.iteritems()]
33967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33968 
 
33969 
  def __eq__(self, other):
33970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33971 
 
33972 
  def __ne__(self, other):
33973 
    return not (self == other)
33974 
 
33975 
class getAmazonOrdersCancelled_args:
33976 
  """
33977 
  Attributes:
33978 
   - interval
33979 
  """
33980 
 
33981 
  thrift_spec = (
33982 
    None, # 0
33983 
    (1, TType.I64, 'interval', None, None, ), # 1
33984 
  )
33985 
 
33986 
  def __init__(self, interval=None,):
33987 
    self.interval = interval
33988 
 
33989 
  def read(self, iprot):
33990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33992 
      return
33993 
    iprot.readStructBegin()
33994 
    while True:
33995 
      (fname, ftype, fid) = iprot.readFieldBegin()
33996 
      if ftype == TType.STOP:
33997 
        break
33998 
      if fid == 1:
33999 
        if ftype == TType.I64:
34000 
          self.interval = iprot.readI64();
34001 
        else:
34002 
          iprot.skip(ftype)
34003 
      else:
34004 
        iprot.skip(ftype)
34005 
      iprot.readFieldEnd()
34006 
    iprot.readStructEnd()
34007 
 
34008 
  def write(self, oprot):
34009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34011 
      return
34012 
    oprot.writeStructBegin('getAmazonOrdersCancelled_args')
34013 
    if self.interval is not None:
34014 
      oprot.writeFieldBegin('interval', TType.I64, 1)
34015 
      oprot.writeI64(self.interval)
34016 
      oprot.writeFieldEnd()
34017 
    oprot.writeFieldStop()
34018 
    oprot.writeStructEnd()
34019 
 
34020 
  def validate(self):
34021 
    return
34022 
 
34023 
 
34024 
  def __repr__(self):
34025 
    L = ['%s=%r' % (key, value)
34026 
      for key, value in self.__dict__.iteritems()]
34027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34028 
 
34029 
  def __eq__(self, other):
34030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34031 
 
34032 
  def __ne__(self, other):
34033 
    return not (self == other)
34034 
 
34035 
class getAmazonOrdersCancelled_result:
34036 
  """
34037 
  Attributes:
34038 
   - success
34039 
  """
34040 
 
34041 
  thrift_spec = (
34042 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
34043 
  )
34044 
 
34045 
  def __init__(self, success=None,):
34046 
    self.success = success
34047 
 
34048 
  def read(self, iprot):
34049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34051 
      return
34052 
    iprot.readStructBegin()
34053 
    while True:
34054 
      (fname, ftype, fid) = iprot.readFieldBegin()
34055 
      if ftype == TType.STOP:
34056 
        break
34057 
      if fid == 0:
34058 
        if ftype == TType.LIST:
34059 
          self.success = []
34060 
          (_etype789, _size786) = iprot.readListBegin()
34061 
          for _i790 in xrange(_size786):
34062 
            _elem791 = Order()
34063 
            _elem791.read(iprot)
34064 
            self.success.append(_elem791)
34065 
          iprot.readListEnd()
34066 
        else:
34067 
          iprot.skip(ftype)
34068 
      else:
34069 
        iprot.skip(ftype)
34070 
      iprot.readFieldEnd()
34071 
    iprot.readStructEnd()
34072 
 
34073 
  def write(self, oprot):
34074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34076 
      return
34077 
    oprot.writeStructBegin('getAmazonOrdersCancelled_result')
34078 
    if self.success is not None:
34079 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34080 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
34081 
      for iter792 in self.success:
34082 
        iter792.write(oprot)
34083 
      oprot.writeListEnd()
34084 
      oprot.writeFieldEnd()
34085 
    oprot.writeFieldStop()
34086 
    oprot.writeStructEnd()
34087 
 
34088 
  def validate(self):
34089 
    return
34090 
 
34091 
 
34092 
  def __repr__(self):
34093 
    L = ['%s=%r' % (key, value)
34094 
      for key, value in self.__dict__.iteritems()]
34095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34096 
 
34097 
  def __eq__(self, other):
34098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34099 
 
34100 
  def __ne__(self, other):
34101 
    return not (self == other)
7322 vikram.rag 34102 
 
34103 
class getAmazonOrder_args:
34104 
  """
34105 
  Attributes:
34106 
   - orderId
34107 
  """
34108 
 
34109 
  thrift_spec = (
34110 
    None, # 0
34111 
    (1, TType.I64, 'orderId', None, None, ), # 1
34112 
  )
34113 
 
34114 
  def __init__(self, orderId=None,):
34115 
    self.orderId = orderId
34116 
 
34117 
  def read(self, iprot):
34118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34120 
      return
34121 
    iprot.readStructBegin()
34122 
    while True:
34123 
      (fname, ftype, fid) = iprot.readFieldBegin()
34124 
      if ftype == TType.STOP:
34125 
        break
34126 
      if fid == 1:
34127 
        if ftype == TType.I64:
34128 
          self.orderId = iprot.readI64();
34129 
        else:
34130 
          iprot.skip(ftype)
34131 
      else:
34132 
        iprot.skip(ftype)
34133 
      iprot.readFieldEnd()
34134 
    iprot.readStructEnd()
34135 
 
34136 
  def write(self, oprot):
34137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34139 
      return
34140 
    oprot.writeStructBegin('getAmazonOrder_args')
34141 
    if self.orderId is not None:
34142 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
34143 
      oprot.writeI64(self.orderId)
34144 
      oprot.writeFieldEnd()
34145 
    oprot.writeFieldStop()
34146 
    oprot.writeStructEnd()
34147 
 
34148 
  def validate(self):
34149 
    return
34150 
 
34151 
 
34152 
  def __repr__(self):
34153 
    L = ['%s=%r' % (key, value)
34154 
      for key, value in self.__dict__.iteritems()]
34155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34156 
 
34157 
  def __eq__(self, other):
34158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34159 
 
34160 
  def __ne__(self, other):
34161 
    return not (self == other)
34162 
 
34163 
class getAmazonOrder_result:
34164 
  """
34165 
  Attributes:
34166 
   - success
34167 
  """
34168 
 
34169 
  thrift_spec = (
34170 
    (0, TType.STRUCT, 'success', (AmazonOrder, AmazonOrder.thrift_spec), None, ), # 0
34171 
  )
34172 
 
34173 
  def __init__(self, success=None,):
34174 
    self.success = success
34175 
 
34176 
  def read(self, iprot):
34177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34179 
      return
34180 
    iprot.readStructBegin()
34181 
    while True:
34182 
      (fname, ftype, fid) = iprot.readFieldBegin()
34183 
      if ftype == TType.STOP:
34184 
        break
34185 
      if fid == 0:
34186 
        if ftype == TType.STRUCT:
34187 
          self.success = AmazonOrder()
34188 
          self.success.read(iprot)
34189 
        else:
34190 
          iprot.skip(ftype)
34191 
      else:
34192 
        iprot.skip(ftype)
34193 
      iprot.readFieldEnd()
34194 
    iprot.readStructEnd()
34195 
 
34196 
  def write(self, oprot):
34197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34199 
      return
34200 
    oprot.writeStructBegin('getAmazonOrder_result')
34201 
    if self.success is not None:
34202 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
34203 
      self.success.write(oprot)
34204 
      oprot.writeFieldEnd()
34205 
    oprot.writeFieldStop()
34206 
    oprot.writeStructEnd()
34207 
 
34208 
  def validate(self):
34209 
    return
34210 
 
34211 
 
34212 
  def __repr__(self):
34213 
    L = ['%s=%r' % (key, value)
34214 
      for key, value in self.__dict__.iteritems()]
34215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34216 
 
34217 
  def __eq__(self, other):
34218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34219 
 
34220 
  def __ne__(self, other):
34221 
    return not (self == other)