Subversion Repositories SmartDukaan

Rev

Rev 7343 | Rev 7370 | 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 
 
7363 rajveer 1594 
  def getSaholicRechargeBalance(self, ):
1595 
    pass
1596 
 
7285 rajveer 1597 
  def getSourceDetail(self, source):
7267 anupam.sin 1598 
    """
1599 
    Parameters:
7285 rajveer 1600 
     - source
7267 anupam.sin 1601 
    """
1602 
    pass
1603 
 
7308 rajveer 1604 
  def getAllCircles(self, ):
1605 
    pass
7267 anupam.sin 1606 
 
7308 rajveer 1607 
  def deleteFrcs(self, frcIdsToDelete):
1608 
    """
1609 
    Parameters:
1610 
     - frcIdsToDelete
1611 
    """
1612 
    pass
1613 
 
7311 kshitij.so 1614 
  def addAmazonOrder(self, amazonOrder):
1615 
    """
1616 
    Parameters:
1617 
     - amazonOrder
1618 
    """
1619 
    pass
7308 rajveer 1620 
 
7322 vikram.rag 1621 
  def updateAmazonOrderStatus(self, orderId, status):
7311 kshitij.so 1622 
    """
1623 
    Parameters:
1624 
     - orderId
1625 
     - status
1626 
    """
1627 
    pass
1628 
 
1629 
  def getAmazonOrdersShipped(self, interval):
1630 
    """
1631 
    Parameters:
1632 
     - interval
1633 
    """
1634 
    pass
1635 
 
1636 
  def getAmazonOrdersCancelled(self, interval):
1637 
    """
1638 
    Parameters:
1639 
     - interval
1640 
    """
1641 
    pass
1642 
 
7322 vikram.rag 1643 
  def getAmazonOrder(self, orderId):
1644 
    """
1645 
    Parameters:
1646 
     - orderId
1647 
    """
1648 
    pass
7311 kshitij.so 1649 
 
7343 anupam.sin 1650 
  def getOrdersForStore(self, id, storeId, startDate, endDate, statuses):
1651 
    """
1652 
    Parameters:
1653 
     - id
1654 
     - storeId
1655 
     - startDate
1656 
     - endDate
1657 
     - statuses
1658 
    """
1659 
    pass
7322 vikram.rag 1660 
 
7343 anupam.sin 1661 
  def getStoreOrderAdvanceInvoice(self, orderId):
1662 
    """
1663 
    Parameters:
1664 
     - orderId
1665 
    """
1666 
    pass
1667 
 
1668 
 
3376 rajveer 1669 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1670 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1671 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1672 
 
1673 
  def createTransaction(self, transaction):
1674 
    """
1675 
    Parameters:
1676 
     - transaction
1677 
    """
1678 
    self.send_createTransaction(transaction)
132 ashish 1679 
    return self.recv_createTransaction()
94 ashish 1680 
 
1681 
  def send_createTransaction(self, transaction):
1682 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1683 
    args = createTransaction_args()
1684 
    args.transaction = transaction
1685 
    args.write(self._oprot)
1686 
    self._oprot.writeMessageEnd()
1687 
    self._oprot.trans.flush()
1688 
 
1689 
  def recv_createTransaction(self, ):
1690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1691 
    if mtype == TMessageType.EXCEPTION:
1692 
      x = TApplicationException()
1693 
      x.read(self._iprot)
1694 
      self._iprot.readMessageEnd()
1695 
      raise x
1696 
    result = createTransaction_result()
1697 
    result.read(self._iprot)
1698 
    self._iprot.readMessageEnd()
3431 rajveer 1699 
    if result.success is not None:
132 ashish 1700 
      return result.success
3431 rajveer 1701 
    if result.ex is not None:
94 ashish 1702 
      raise result.ex
132 ashish 1703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1704 
 
1705 
  def getTransaction(self, id):
1706 
    """
1707 
    Parameters:
1708 
     - id
1709 
    """
1710 
    self.send_getTransaction(id)
1711 
    return self.recv_getTransaction()
1712 
 
1713 
  def send_getTransaction(self, id):
1714 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1715 
    args = getTransaction_args()
1716 
    args.id = id
1717 
    args.write(self._oprot)
1718 
    self._oprot.writeMessageEnd()
1719 
    self._oprot.trans.flush()
1720 
 
1721 
  def recv_getTransaction(self, ):
1722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1723 
    if mtype == TMessageType.EXCEPTION:
1724 
      x = TApplicationException()
1725 
      x.read(self._iprot)
1726 
      self._iprot.readMessageEnd()
1727 
      raise x
1728 
    result = getTransaction_result()
1729 
    result.read(self._iprot)
1730 
    self._iprot.readMessageEnd()
3431 rajveer 1731 
    if result.success is not None:
94 ashish 1732 
      return result.success
3431 rajveer 1733 
    if result.ex is not None:
94 ashish 1734 
      raise result.ex
1735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1736 
 
1737 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1738 
    """
1739 
    Parameters:
1740 
     - customerId
1741 
     - from_date
1742 
     - to_date
1743 
     - status
1744 
    """
1745 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1746 
    return self.recv_getTransactionsForCustomer()
1747 
 
1748 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1749 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1750 
    args = getTransactionsForCustomer_args()
1751 
    args.customerId = customerId
1752 
    args.from_date = from_date
1753 
    args.to_date = to_date
1754 
    args.status = status
1755 
    args.write(self._oprot)
1756 
    self._oprot.writeMessageEnd()
1757 
    self._oprot.trans.flush()
1758 
 
1759 
  def recv_getTransactionsForCustomer(self, ):
1760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1761 
    if mtype == TMessageType.EXCEPTION:
1762 
      x = TApplicationException()
1763 
      x.read(self._iprot)
1764 
      self._iprot.readMessageEnd()
1765 
      raise x
1766 
    result = getTransactionsForCustomer_result()
1767 
    result.read(self._iprot)
1768 
    self._iprot.readMessageEnd()
3431 rajveer 1769 
    if result.success is not None:
94 ashish 1770 
      return result.success
3431 rajveer 1771 
    if result.ex is not None:
94 ashish 1772 
      raise result.ex
1773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1774 
 
132 ashish 1775 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1776 
    """
1777 
    Parameters:
1778 
     - shoppingCartId
1779 
    """
1780 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1781 
    return self.recv_getTransactionsForShoppingCartId()
1782 
 
1783 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1784 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1785 
    args = getTransactionsForShoppingCartId_args()
1786 
    args.shoppingCartId = shoppingCartId
1787 
    args.write(self._oprot)
1788 
    self._oprot.writeMessageEnd()
1789 
    self._oprot.trans.flush()
1790 
 
1791 
  def recv_getTransactionsForShoppingCartId(self, ):
1792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1793 
    if mtype == TMessageType.EXCEPTION:
1794 
      x = TApplicationException()
1795 
      x.read(self._iprot)
1796 
      self._iprot.readMessageEnd()
1797 
      raise x
1798 
    result = getTransactionsForShoppingCartId_result()
1799 
    result.read(self._iprot)
1800 
    self._iprot.readMessageEnd()
3431 rajveer 1801 
    if result.success is not None:
132 ashish 1802 
      return result.success
3431 rajveer 1803 
    if result.ex is not None:
132 ashish 1804 
      raise result.ex
1805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1806 
 
94 ashish 1807 
  def getTransactionStatus(self, transactionId):
1808 
    """
1809 
    Parameters:
1810 
     - transactionId
1811 
    """
1812 
    self.send_getTransactionStatus(transactionId)
1813 
    return self.recv_getTransactionStatus()
1814 
 
1815 
  def send_getTransactionStatus(self, transactionId):
1816 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1817 
    args = getTransactionStatus_args()
1818 
    args.transactionId = transactionId
1819 
    args.write(self._oprot)
1820 
    self._oprot.writeMessageEnd()
1821 
    self._oprot.trans.flush()
1822 
 
1823 
  def recv_getTransactionStatus(self, ):
1824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1825 
    if mtype == TMessageType.EXCEPTION:
1826 
      x = TApplicationException()
1827 
      x.read(self._iprot)
1828 
      self._iprot.readMessageEnd()
1829 
      raise x
1830 
    result = getTransactionStatus_result()
1831 
    result.read(self._iprot)
1832 
    self._iprot.readMessageEnd()
3431 rajveer 1833 
    if result.success is not None:
94 ashish 1834 
      return result.success
3431 rajveer 1835 
    if result.ex is not None:
94 ashish 1836 
      raise result.ex
1837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1838 
 
7293 anupam.sin 1839 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1840 
    """
1841 
    Parameters:
1842 
     - transactionId
1843 
     - status
1844 
     - description
5527 anupam.sin 1845 
     - pickUp
1846 
     - orderType
7293 anupam.sin 1847 
     - source
94 ashish 1848 
    """
7293 anupam.sin 1849 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType, source)
94 ashish 1850 
    return self.recv_changeTransactionStatus()
1851 
 
7293 anupam.sin 1852 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1853 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1854 
    args = changeTransactionStatus_args()
1855 
    args.transactionId = transactionId
1856 
    args.status = status
1857 
    args.description = description
5527 anupam.sin 1858 
    args.pickUp = pickUp
1859 
    args.orderType = orderType
7293 anupam.sin 1860 
    args.source = source
94 ashish 1861 
    args.write(self._oprot)
1862 
    self._oprot.writeMessageEnd()
1863 
    self._oprot.trans.flush()
1864 
 
1865 
  def recv_changeTransactionStatus(self, ):
1866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1867 
    if mtype == TMessageType.EXCEPTION:
1868 
      x = TApplicationException()
1869 
      x.read(self._iprot)
1870 
      self._iprot.readMessageEnd()
1871 
      raise x
1872 
    result = changeTransactionStatus_result()
1873 
    result.read(self._iprot)
1874 
    self._iprot.readMessageEnd()
3431 rajveer 1875 
    if result.success is not None:
94 ashish 1876 
      return result.success
3431 rajveer 1877 
    if result.ex is not None:
94 ashish 1878 
      raise result.ex
1879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1880 
 
1398 varun.gupt 1881 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1882 
    """
1883 
    Parameters:
1884 
     - transactionId
1885 
    """
1398 varun.gupt 1886 
    self.send_enqueueTransactionInfoEmail(transactionId)
1887 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1888 
 
1398 varun.gupt 1889 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1890 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1891 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1892 
    args.transactionId = transactionId
1893 
    args.write(self._oprot)
1894 
    self._oprot.writeMessageEnd()
1895 
    self._oprot.trans.flush()
1896 
 
1398 varun.gupt 1897 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1899 
    if mtype == TMessageType.EXCEPTION:
1900 
      x = TApplicationException()
1901 
      x.read(self._iprot)
1902 
      self._iprot.readMessageEnd()
1903 
      raise x
1398 varun.gupt 1904 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1905 
    result.read(self._iprot)
1906 
    self._iprot.readMessageEnd()
3431 rajveer 1907 
    if result.success is not None:
1382 varun.gupt 1908 
      return result.success
3431 rajveer 1909 
    if result.ex is not None:
1382 varun.gupt 1910 
      raise result.ex
1398 varun.gupt 1911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1912 
 
4801 anupam.sin 1913 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1914 
    """
1915 
    Parameters:
4801 anupam.sin 1916 
     - statuses
483 rajveer 1917 
     - from_date
1918 
     - to_date
1919 
     - warehouse_id
94 ashish 1920 
    """
4801 anupam.sin 1921 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1922 
    return self.recv_getAllOrders()
94 ashish 1923 
 
4801 anupam.sin 1924 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1925 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1926 
    args = getAllOrders_args()
4801 anupam.sin 1927 
    args.statuses = statuses
483 rajveer 1928 
    args.from_date = from_date
1929 
    args.to_date = to_date
1930 
    args.warehouse_id = warehouse_id
94 ashish 1931 
    args.write(self._oprot)
1932 
    self._oprot.writeMessageEnd()
1933 
    self._oprot.trans.flush()
1934 
 
483 rajveer 1935 
  def recv_getAllOrders(self, ):
94 ashish 1936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1937 
    if mtype == TMessageType.EXCEPTION:
1938 
      x = TApplicationException()
1939 
      x.read(self._iprot)
1940 
      self._iprot.readMessageEnd()
1941 
      raise x
483 rajveer 1942 
    result = getAllOrders_result()
94 ashish 1943 
    result.read(self._iprot)
1944 
    self._iprot.readMessageEnd()
3431 rajveer 1945 
    if result.success is not None:
94 ashish 1946 
      return result.success
3431 rajveer 1947 
    if result.ex is not None:
94 ashish 1948 
      raise result.ex
483 rajveer 1949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1950 
 
4133 chandransh 1951 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1952 
    """
1953 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1954 
    Pass the status as null and the limit as 0 to ignore them.
1955 
 
1956 
    Parameters:
1957 
     - statuses
1958 
     - offset
1959 
     - limit
1960 
     - warehouse_id
1961 
    """
1962 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1963 
    return self.recv_getOrdersInBatch()
1964 
 
1965 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1966 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1967 
    args = getOrdersInBatch_args()
1968 
    args.statuses = statuses
1969 
    args.offset = offset
1970 
    args.limit = limit
1971 
    args.warehouse_id = warehouse_id
1972 
    args.write(self._oprot)
1973 
    self._oprot.writeMessageEnd()
1974 
    self._oprot.trans.flush()
1975 
 
1976 
  def recv_getOrdersInBatch(self, ):
1977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1978 
    if mtype == TMessageType.EXCEPTION:
1979 
      x = TApplicationException()
1980 
      x.read(self._iprot)
1981 
      self._iprot.readMessageEnd()
1982 
      raise x
1983 
    result = getOrdersInBatch_result()
1984 
    result.read(self._iprot)
1985 
    self._iprot.readMessageEnd()
1986 
    if result.success is not None:
1987 
      return result.success
1988 
    if result.ex is not None:
1989 
      raise result.ex
1990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1991 
 
1992 
  def getOrderCount(self, statuses, warehouseId):
1993 
    """
1994 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1995 
 
1996 
    Parameters:
1997 
     - statuses
1998 
     - warehouseId
1999 
    """
2000 
    self.send_getOrderCount(statuses, warehouseId)
2001 
    return self.recv_getOrderCount()
2002 
 
2003 
  def send_getOrderCount(self, statuses, warehouseId):
2004 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
2005 
    args = getOrderCount_args()
2006 
    args.statuses = statuses
2007 
    args.warehouseId = warehouseId
2008 
    args.write(self._oprot)
2009 
    self._oprot.writeMessageEnd()
2010 
    self._oprot.trans.flush()
2011 
 
2012 
  def recv_getOrderCount(self, ):
2013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2014 
    if mtype == TMessageType.EXCEPTION:
2015 
      x = TApplicationException()
2016 
      x.read(self._iprot)
2017 
      self._iprot.readMessageEnd()
2018 
      raise x
2019 
    result = getOrderCount_result()
2020 
    result.read(self._iprot)
2021 
    self._iprot.readMessageEnd()
2022 
    if result.success is not None:
2023 
      return result.success
2024 
    if result.ex is not None:
2025 
      raise result.ex
2026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
2027 
 
999 varun.gupt 2028 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
2029 
    """
1132 chandransh 2030 
    Returns orders within a range of their billing dates
3431 rajveer 2031 
 
999 varun.gupt 2032 
    Parameters:
2033 
     - status
2034 
     - start_billing_date
2035 
     - end_billing_date
2036 
     - warehouse_id
2037 
    """
2038 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
2039 
    return self.recv_getOrdersByBillingDate()
2040 
 
2041 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
2042 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
2043 
    args = getOrdersByBillingDate_args()
2044 
    args.status = status
2045 
    args.start_billing_date = start_billing_date
2046 
    args.end_billing_date = end_billing_date
2047 
    args.warehouse_id = warehouse_id
2048 
    args.write(self._oprot)
2049 
    self._oprot.writeMessageEnd()
2050 
    self._oprot.trans.flush()
2051 
 
2052 
  def recv_getOrdersByBillingDate(self, ):
2053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2054 
    if mtype == TMessageType.EXCEPTION:
2055 
      x = TApplicationException()
2056 
      x.read(self._iprot)
2057 
      self._iprot.readMessageEnd()
2058 
      raise x
2059 
    result = getOrdersByBillingDate_result()
2060 
    result.read(self._iprot)
2061 
    self._iprot.readMessageEnd()
3431 rajveer 2062 
    if result.success is not None:
999 varun.gupt 2063 
      return result.success
3431 rajveer 2064 
    if result.ex is not None:
999 varun.gupt 2065 
      raise result.ex
2066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
2067 
 
3451 chandransh 2068 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2069 
    """
2070 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 2071 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
2072 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 2073 
 
3427 chandransh 2074 
    Parameters:
2075 
     - fromShippingDate
2076 
     - toShippingDate
2077 
     - providerId
2078 
     - warehouseId
3451 chandransh 2079 
     - cod
3427 chandransh 2080 
    """
3451 chandransh 2081 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 2082 
    return self.recv_getOrdersByShippingDate()
2083 
 
3451 chandransh 2084 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2085 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
2086 
    args = getOrdersByShippingDate_args()
2087 
    args.fromShippingDate = fromShippingDate
2088 
    args.toShippingDate = toShippingDate
2089 
    args.providerId = providerId
2090 
    args.warehouseId = warehouseId
3451 chandransh 2091 
    args.cod = cod
3427 chandransh 2092 
    args.write(self._oprot)
2093 
    self._oprot.writeMessageEnd()
2094 
    self._oprot.trans.flush()
2095 
 
2096 
  def recv_getOrdersByShippingDate(self, ):
2097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2098 
    if mtype == TMessageType.EXCEPTION:
2099 
      x = TApplicationException()
2100 
      x.read(self._iprot)
2101 
      self._iprot.readMessageEnd()
2102 
      raise x
2103 
    result = getOrdersByShippingDate_result()
2104 
    result.read(self._iprot)
2105 
    self._iprot.readMessageEnd()
3431 rajveer 2106 
    if result.success is not None:
3427 chandransh 2107 
      return result.success
3431 rajveer 2108 
    if result.ex is not None:
3427 chandransh 2109 
      raise result.ex
2110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
2111 
 
1382 varun.gupt 2112 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
2113 
    """
2114 
    Returns order ids for orders which can be returned
3431 rajveer 2115 
 
1382 varun.gupt 2116 
    Parameters:
2117 
     - customer_id
2118 
     - limit
2119 
    """
2120 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2121 
    return self.recv_getReturnableOrdersForCustomer()
2122 
 
2123 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2124 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2125 
    args = getReturnableOrdersForCustomer_args()
2126 
    args.customer_id = customer_id
2127 
    args.limit = limit
2128 
    args.write(self._oprot)
2129 
    self._oprot.writeMessageEnd()
2130 
    self._oprot.trans.flush()
2131 
 
2132 
  def recv_getReturnableOrdersForCustomer(self, ):
2133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2134 
    if mtype == TMessageType.EXCEPTION:
2135 
      x = TApplicationException()
2136 
      x.read(self._iprot)
2137 
      self._iprot.readMessageEnd()
2138 
      raise x
2139 
    result = getReturnableOrdersForCustomer_result()
2140 
    result.read(self._iprot)
2141 
    self._iprot.readMessageEnd()
3431 rajveer 2142 
    if result.success is not None:
1382 varun.gupt 2143 
      return result.success
3431 rajveer 2144 
    if result.ex is not None:
1382 varun.gupt 2145 
      raise result.ex
2146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2147 
 
2148 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2149 
    """
2150 
    Returns order ids for orders which can be cancelled
3431 rajveer 2151 
 
1382 varun.gupt 2152 
    Parameters:
2153 
     - customer_id
2154 
     - limit
2155 
    """
2156 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2157 
    return self.recv_getCancellableOrdersForCustomer()
2158 
 
2159 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2160 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2161 
    args = getCancellableOrdersForCustomer_args()
2162 
    args.customer_id = customer_id
2163 
    args.limit = limit
2164 
    args.write(self._oprot)
2165 
    self._oprot.writeMessageEnd()
2166 
    self._oprot.trans.flush()
2167 
 
2168 
  def recv_getCancellableOrdersForCustomer(self, ):
2169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2170 
    if mtype == TMessageType.EXCEPTION:
2171 
      x = TApplicationException()
2172 
      x.read(self._iprot)
2173 
      self._iprot.readMessageEnd()
2174 
      raise x
2175 
    result = getCancellableOrdersForCustomer_result()
2176 
    result.read(self._iprot)
2177 
    self._iprot.readMessageEnd()
3431 rajveer 2178 
    if result.success is not None:
1382 varun.gupt 2179 
      return result.success
3431 rajveer 2180 
    if result.ex is not None:
1382 varun.gupt 2181 
      raise result.ex
2182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2183 
 
483 rajveer 2184 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2185 
    """
2186 
    Parameters:
483 rajveer 2187 
     - orderId
2188 
     - status
2189 
     - description
94 ashish 2190 
    """
483 rajveer 2191 
    self.send_changeOrderStatus(orderId, status, description)
2192 
    return self.recv_changeOrderStatus()
94 ashish 2193 
 
483 rajveer 2194 
  def send_changeOrderStatus(self, orderId, status, description):
2195 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2196 
    args = changeOrderStatus_args()
2197 
    args.orderId = orderId
2198 
    args.status = status
2199 
    args.description = description
94 ashish 2200 
    args.write(self._oprot)
2201 
    self._oprot.writeMessageEnd()
2202 
    self._oprot.trans.flush()
2203 
 
483 rajveer 2204 
  def recv_changeOrderStatus(self, ):
94 ashish 2205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2206 
    if mtype == TMessageType.EXCEPTION:
2207 
      x = TApplicationException()
2208 
      x.read(self._iprot)
2209 
      self._iprot.readMessageEnd()
2210 
      raise x
483 rajveer 2211 
    result = changeOrderStatus_result()
94 ashish 2212 
    result.read(self._iprot)
2213 
    self._iprot.readMessageEnd()
3431 rajveer 2214 
    if result.success is not None:
94 ashish 2215 
      return result.success
3431 rajveer 2216 
    if result.ex is not None:
94 ashish 2217 
      raise result.ex
483 rajveer 2218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2219 
 
1528 ankur.sing 2220 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2221 
    """
1528 ankur.sing 2222 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2223 
    only user who owns the transaction can view its order details.
3431 rajveer 2224 
 
94 ashish 2225 
    Parameters:
2226 
     - transactionId
1528 ankur.sing 2227 
     - customerId
94 ashish 2228 
    """
1528 ankur.sing 2229 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2230 
    return self.recv_getOrdersForTransaction()
94 ashish 2231 
 
1528 ankur.sing 2232 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2233 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2234 
    args = getOrdersForTransaction_args()
94 ashish 2235 
    args.transactionId = transactionId
1528 ankur.sing 2236 
    args.customerId = customerId
94 ashish 2237 
    args.write(self._oprot)
2238 
    self._oprot.writeMessageEnd()
2239 
    self._oprot.trans.flush()
2240 
 
483 rajveer 2241 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2243 
    if mtype == TMessageType.EXCEPTION:
2244 
      x = TApplicationException()
2245 
      x.read(self._iprot)
2246 
      self._iprot.readMessageEnd()
2247 
      raise x
483 rajveer 2248 
    result = getOrdersForTransaction_result()
94 ashish 2249 
    result.read(self._iprot)
2250 
    self._iprot.readMessageEnd()
3431 rajveer 2251 
    if result.success is not None:
94 ashish 2252 
      return result.success
3431 rajveer 2253 
    if result.ex is not None:
94 ashish 2254 
      raise result.ex
483 rajveer 2255 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2256 
 
3014 chandransh 2257 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2258 
    """
3014 chandransh 2259 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2260 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2261 
 
94 ashish 2262 
    Parameters:
483 rajveer 2263 
     - customerId
2264 
     - from_date
2265 
     - to_date
3014 chandransh 2266 
     - statuses
94 ashish 2267 
    """
3014 chandransh 2268 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2269 
    return self.recv_getOrdersForCustomer()
94 ashish 2270 
 
3014 chandransh 2271 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2272 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2273 
    args = getOrdersForCustomer_args()
2274 
    args.customerId = customerId
2275 
    args.from_date = from_date
2276 
    args.to_date = to_date
3014 chandransh 2277 
    args.statuses = statuses
94 ashish 2278 
    args.write(self._oprot)
2279 
    self._oprot.writeMessageEnd()
2280 
    self._oprot.trans.flush()
2281 
 
483 rajveer 2282 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2284 
    if mtype == TMessageType.EXCEPTION:
2285 
      x = TApplicationException()
2286 
      x.read(self._iprot)
2287 
      self._iprot.readMessageEnd()
2288 
      raise x
483 rajveer 2289 
    result = getOrdersForCustomer_result()
94 ashish 2290 
    result.read(self._iprot)
2291 
    self._iprot.readMessageEnd()
3431 rajveer 2292 
    if result.success is not None:
94 ashish 2293 
      return result.success
3431 rajveer 2294 
    if result.ex is not None:
94 ashish 2295 
      raise result.ex
483 rajveer 2296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2297 
 
483 rajveer 2298 
  def createOrder(self, order):
94 ashish 2299 
    """
2300 
    Parameters:
483 rajveer 2301 
     - order
94 ashish 2302 
    """
483 rajveer 2303 
    self.send_createOrder(order)
2304 
    return self.recv_createOrder()
94 ashish 2305 
 
483 rajveer 2306 
  def send_createOrder(self, order):
2307 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2308 
    args = createOrder_args()
2309 
    args.order = order
94 ashish 2310 
    args.write(self._oprot)
2311 
    self._oprot.writeMessageEnd()
2312 
    self._oprot.trans.flush()
2313 
 
483 rajveer 2314 
  def recv_createOrder(self, ):
94 ashish 2315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2316 
    if mtype == TMessageType.EXCEPTION:
2317 
      x = TApplicationException()
2318 
      x.read(self._iprot)
2319 
      self._iprot.readMessageEnd()
2320 
      raise x
483 rajveer 2321 
    result = createOrder_result()
94 ashish 2322 
    result.read(self._iprot)
2323 
    self._iprot.readMessageEnd()
3431 rajveer 2324 
    if result.success is not None:
94 ashish 2325 
      return result.success
3431 rajveer 2326 
    if result.ex is not None:
94 ashish 2327 
      raise result.ex
483 rajveer 2328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2329 
 
483 rajveer 2330 
  def getOrder(self, id):
94 ashish 2331 
    """
2332 
    Parameters:
483 rajveer 2333 
     - id
94 ashish 2334 
    """
483 rajveer 2335 
    self.send_getOrder(id)
2336 
    return self.recv_getOrder()
94 ashish 2337 
 
483 rajveer 2338 
  def send_getOrder(self, id):
2339 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2340 
    args = getOrder_args()
2341 
    args.id = id
94 ashish 2342 
    args.write(self._oprot)
2343 
    self._oprot.writeMessageEnd()
2344 
    self._oprot.trans.flush()
2345 
 
483 rajveer 2346 
  def recv_getOrder(self, ):
94 ashish 2347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2348 
    if mtype == TMessageType.EXCEPTION:
2349 
      x = TApplicationException()
2350 
      x.read(self._iprot)
2351 
      self._iprot.readMessageEnd()
2352 
      raise x
483 rajveer 2353 
    result = getOrder_result()
94 ashish 2354 
    result.read(self._iprot)
2355 
    self._iprot.readMessageEnd()
3431 rajveer 2356 
    if result.success is not None:
94 ashish 2357 
      return result.success
3431 rajveer 2358 
    if result.ex is not None:
94 ashish 2359 
      raise result.ex
483 rajveer 2360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2361 
 
483 rajveer 2362 
  def getLineItemsForOrder(self, orderId):
94 ashish 2363 
    """
2364 
    Parameters:
483 rajveer 2365 
     - orderId
94 ashish 2366 
    """
483 rajveer 2367 
    self.send_getLineItemsForOrder(orderId)
2368 
    return self.recv_getLineItemsForOrder()
94 ashish 2369 
 
483 rajveer 2370 
  def send_getLineItemsForOrder(self, orderId):
2371 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2372 
    args = getLineItemsForOrder_args()
2373 
    args.orderId = orderId
94 ashish 2374 
    args.write(self._oprot)
2375 
    self._oprot.writeMessageEnd()
2376 
    self._oprot.trans.flush()
2377 
 
483 rajveer 2378 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2380 
    if mtype == TMessageType.EXCEPTION:
2381 
      x = TApplicationException()
2382 
      x.read(self._iprot)
2383 
      self._iprot.readMessageEnd()
2384 
      raise x
483 rajveer 2385 
    result = getLineItemsForOrder_result()
94 ashish 2386 
    result.read(self._iprot)
2387 
    self._iprot.readMessageEnd()
3431 rajveer 2388 
    if result.success is not None:
94 ashish 2389 
      return result.success
3431 rajveer 2390 
    if result.ex is not None:
94 ashish 2391 
      raise result.ex
483 rajveer 2392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2393 
 
4999 phani.kuma 2394 
  def getOrderList(self, order_ids):
2395 
    """
2396 
    Parameters:
2397 
     - order_ids
2398 
    """
2399 
    self.send_getOrderList(order_ids)
2400 
    return self.recv_getOrderList()
2401 
 
2402 
  def send_getOrderList(self, order_ids):
2403 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2404 
    args = getOrderList_args()
2405 
    args.order_ids = order_ids
2406 
    args.write(self._oprot)
2407 
    self._oprot.writeMessageEnd()
2408 
    self._oprot.trans.flush()
2409 
 
2410 
  def recv_getOrderList(self, ):
2411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2412 
    if mtype == TMessageType.EXCEPTION:
2413 
      x = TApplicationException()
2414 
      x.read(self._iprot)
2415 
      self._iprot.readMessageEnd()
2416 
      raise x
2417 
    result = getOrderList_result()
2418 
    result.read(self._iprot)
2419 
    self._iprot.readMessageEnd()
2420 
    if result.success is not None:
2421 
      return result.success
2422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2423 
 
5386 phani.kuma 2424 
  def getOrderListForVendor(self, order_ids, vendorId):
2425 
    """
2426 
    Parameters:
2427 
     - order_ids
2428 
     - vendorId
2429 
    """
2430 
    self.send_getOrderListForVendor(order_ids, vendorId)
2431 
    return self.recv_getOrderListForVendor()
2432 
 
2433 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2434 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2435 
    args = getOrderListForVendor_args()
2436 
    args.order_ids = order_ids
2437 
    args.vendorId = vendorId
2438 
    args.write(self._oprot)
2439 
    self._oprot.writeMessageEnd()
2440 
    self._oprot.trans.flush()
2441 
 
2442 
  def recv_getOrderListForVendor(self, ):
2443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2444 
    if mtype == TMessageType.EXCEPTION:
2445 
      x = TApplicationException()
2446 
      x.read(self._iprot)
2447 
      self._iprot.readMessageEnd()
2448 
      raise x
2449 
    result = getOrderListForVendor_result()
2450 
    result.read(self._iprot)
2451 
    self._iprot.readMessageEnd()
2452 
    if result.success is not None:
2453 
      return result.success
2454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2455 
 
1528 ankur.sing 2456 
  def getOrderForCustomer(self, orderId, customerId):
2457 
    """
2458 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2459 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2460 
 
1528 ankur.sing 2461 
    Parameters:
2462 
     - orderId
2463 
     - customerId
2464 
    """
2465 
    self.send_getOrderForCustomer(orderId, customerId)
2466 
    return self.recv_getOrderForCustomer()
2467 
 
2468 
  def send_getOrderForCustomer(self, orderId, customerId):
2469 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2470 
    args = getOrderForCustomer_args()
2471 
    args.orderId = orderId
2472 
    args.customerId = customerId
2473 
    args.write(self._oprot)
2474 
    self._oprot.writeMessageEnd()
2475 
    self._oprot.trans.flush()
2476 
 
2477 
  def recv_getOrderForCustomer(self, ):
2478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2479 
    if mtype == TMessageType.EXCEPTION:
2480 
      x = TApplicationException()
2481 
      x.read(self._iprot)
2482 
      self._iprot.readMessageEnd()
2483 
      raise x
2484 
    result = getOrderForCustomer_result()
2485 
    result.read(self._iprot)
2486 
    self._iprot.readMessageEnd()
3431 rajveer 2487 
    if result.success is not None:
1528 ankur.sing 2488 
      return result.success
3431 rajveer 2489 
    if result.ex is not None:
1528 ankur.sing 2490 
      raise result.ex
2491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2492 
 
4444 rajveer 2493 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2494 
    """
2495 
    Parameters:
4394 rajveer 2496 
     - type
4444 rajveer 2497 
     - warehouseId
4394 rajveer 2498 
     - status
2499 
     - timestamp
3064 chandransh 2500 
    """
4444 rajveer 2501 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2502 
    return self.recv_getAlerts()
2503 
 
4444 rajveer 2504 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2505 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2506 
    args = getAlerts_args()
4394 rajveer 2507 
    args.type = type
4444 rajveer 2508 
    args.warehouseId = warehouseId
4394 rajveer 2509 
    args.status = status
2510 
    args.timestamp = timestamp
3064 chandransh 2511 
    args.write(self._oprot)
2512 
    self._oprot.writeMessageEnd()
2513 
    self._oprot.trans.flush()
2514 
 
2515 
  def recv_getAlerts(self, ):
2516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2517 
    if mtype == TMessageType.EXCEPTION:
2518 
      x = TApplicationException()
2519 
      x.read(self._iprot)
2520 
      self._iprot.readMessageEnd()
2521 
      raise x
2522 
    result = getAlerts_result()
2523 
    result.read(self._iprot)
2524 
    self._iprot.readMessageEnd()
3431 rajveer 2525 
    if result.success is not None:
3064 chandransh 2526 
      return result.success
2527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2528 
 
4444 rajveer 2529 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2530 
    """
2531 
    Parameters:
2532 
     - type
4444 rajveer 2533 
     - warehouseId
4394 rajveer 2534 
     - description
3064 chandransh 2535 
    """
4444 rajveer 2536 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2537 
    self.recv_addAlert()
3064 chandransh 2538 
 
4444 rajveer 2539 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2540 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2541 
    args = addAlert_args()
3064 chandransh 2542 
    args.type = type
4444 rajveer 2543 
    args.warehouseId = warehouseId
4394 rajveer 2544 
    args.description = description
3064 chandransh 2545 
    args.write(self._oprot)
2546 
    self._oprot.writeMessageEnd()
2547 
    self._oprot.trans.flush()
2548 
 
4394 rajveer 2549 
  def recv_addAlert(self, ):
3064 chandransh 2550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2551 
    if mtype == TMessageType.EXCEPTION:
2552 
      x = TApplicationException()
2553 
      x.read(self._iprot)
2554 
      self._iprot.readMessageEnd()
2555 
      raise x
4394 rajveer 2556 
    result = addAlert_result()
3064 chandransh 2557 
    result.read(self._iprot)
2558 
    self._iprot.readMessageEnd()
2559 
    return
2560 
 
4444 rajveer 2561 
  def markAlertsAsSeen(self, warehouseId):
2562 
    """
2563 
    Parameters:
2564 
     - warehouseId
2565 
    """
2566 
    self.send_markAlertsAsSeen(warehouseId)
2567 
    self.recv_markAlertsAsSeen()
2568 
 
2569 
  def send_markAlertsAsSeen(self, warehouseId):
2570 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2571 
    args = markAlertsAsSeen_args()
2572 
    args.warehouseId = warehouseId
2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_markAlertsAsSeen(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = markAlertsAsSeen_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
2587 
    return
2588 
 
3064 chandransh 2589 
  def getValidOrderCount(self, ):
2590 
    """
2591 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2592 
    """
2593 
    self.send_getValidOrderCount()
2594 
    return self.recv_getValidOrderCount()
2595 
 
2596 
  def send_getValidOrderCount(self, ):
2597 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2598 
    args = getValidOrderCount_args()
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_getValidOrderCount(self, ):
2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
2610 
    result = getValidOrderCount_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
3431 rajveer 2613 
    if result.success is not None:
3064 chandransh 2614 
      return result.success
2615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2616 
 
2617 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2618 
    """
2619 
    Returns the number of distinct customers who have done successful transactions
2620 
    """
2621 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2622 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2623 
 
2624 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2625 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2626 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2627 
    args.write(self._oprot)
2628 
    self._oprot.writeMessageEnd()
2629 
    self._oprot.trans.flush()
2630 
 
2631 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2633 
    if mtype == TMessageType.EXCEPTION:
2634 
      x = TApplicationException()
2635 
      x.read(self._iprot)
2636 
      self._iprot.readMessageEnd()
2637 
      raise x
2638 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2639 
    result.read(self._iprot)
2640 
    self._iprot.readMessageEnd()
3431 rajveer 2641 
    if result.success is not None:
3064 chandransh 2642 
      return result.success
2643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2644 
 
2645 
  def getValidOrdersAmountRange(self, ):
2646 
    """
2647 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2648 
    List contains two values, first minimum amount and second maximum amount.
2649 
    """
2650 
    self.send_getValidOrdersAmountRange()
2651 
    return self.recv_getValidOrdersAmountRange()
2652 
 
2653 
  def send_getValidOrdersAmountRange(self, ):
2654 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2655 
    args = getValidOrdersAmountRange_args()
2656 
    args.write(self._oprot)
2657 
    self._oprot.writeMessageEnd()
2658 
    self._oprot.trans.flush()
2659 
 
2660 
  def recv_getValidOrdersAmountRange(self, ):
2661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2662 
    if mtype == TMessageType.EXCEPTION:
2663 
      x = TApplicationException()
2664 
      x.read(self._iprot)
2665 
      self._iprot.readMessageEnd()
2666 
      raise x
2667 
    result = getValidOrdersAmountRange_result()
2668 
    result.read(self._iprot)
2669 
    self._iprot.readMessageEnd()
3431 rajveer 2670 
    if result.success is not None:
3064 chandransh 2671 
      return result.success
2672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2673 
 
5874 rajveer 2674 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2675 
    """
2676 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2677 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2678 
 
3064 chandransh 2679 
    Parameters:
2680 
     - limit
5874 rajveer 2681 
     - onlyStore
3064 chandransh 2682 
    """
5874 rajveer 2683 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2684 
    return self.recv_getValidOrders()
2685 
 
5874 rajveer 2686 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2687 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2688 
    args = getValidOrders_args()
2689 
    args.limit = limit
5874 rajveer 2690 
    args.onlyStore = onlyStore
3064 chandransh 2691 
    args.write(self._oprot)
2692 
    self._oprot.writeMessageEnd()
2693 
    self._oprot.trans.flush()
2694 
 
2695 
  def recv_getValidOrders(self, ):
2696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2697 
    if mtype == TMessageType.EXCEPTION:
2698 
      x = TApplicationException()
2699 
      x.read(self._iprot)
2700 
      self._iprot.readMessageEnd()
2701 
      raise x
2702 
    result = getValidOrders_result()
2703 
    result.read(self._iprot)
2704 
    self._iprot.readMessageEnd()
3431 rajveer 2705 
    if result.success is not None:
3064 chandransh 2706 
      return result.success
2707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2708 
 
1220 chandransh 2709 
  def batchOrders(self, warehouseId):
2710 
    """
2711 
    Create a batch of all the pending orders for the given warehouse.
2712 
    The returned list is orderd by created_timestamp.
2713 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2714 
 
1220 chandransh 2715 
    Parameters:
2716 
     - warehouseId
2717 
    """
2718 
    self.send_batchOrders(warehouseId)
2719 
    return self.recv_batchOrders()
2720 
 
2721 
  def send_batchOrders(self, warehouseId):
2722 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2723 
    args = batchOrders_args()
2724 
    args.warehouseId = warehouseId
2725 
    args.write(self._oprot)
2726 
    self._oprot.writeMessageEnd()
2727 
    self._oprot.trans.flush()
2728 
 
2729 
  def recv_batchOrders(self, ):
2730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2731 
    if mtype == TMessageType.EXCEPTION:
2732 
      x = TApplicationException()
2733 
      x.read(self._iprot)
2734 
      self._iprot.readMessageEnd()
2735 
      raise x
2736 
    result = batchOrders_result()
2737 
    result.read(self._iprot)
2738 
    self._iprot.readMessageEnd()
3431 rajveer 2739 
    if result.success is not None:
1220 chandransh 2740 
      return result.success
3431 rajveer 2741 
    if result.ex is not None:
1220 chandransh 2742 
      raise result.ex
2743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2744 
 
1208 chandransh 2745 
  def markOrderAsOutOfStock(self, orderId):
2746 
    """
2747 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2748 
 
1208 chandransh 2749 
    Parameters:
2750 
     - orderId
2751 
    """
2752 
    self.send_markOrderAsOutOfStock(orderId)
2753 
    return self.recv_markOrderAsOutOfStock()
2754 
 
2755 
  def send_markOrderAsOutOfStock(self, orderId):
2756 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2757 
    args = markOrderAsOutOfStock_args()
2758 
    args.orderId = orderId
2759 
    args.write(self._oprot)
2760 
    self._oprot.writeMessageEnd()
2761 
    self._oprot.trans.flush()
2762 
 
2763 
  def recv_markOrderAsOutOfStock(self, ):
2764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2765 
    if mtype == TMessageType.EXCEPTION:
2766 
      x = TApplicationException()
2767 
      x.read(self._iprot)
2768 
      self._iprot.readMessageEnd()
2769 
      raise x
2770 
    result = markOrderAsOutOfStock_result()
2771 
    result.read(self._iprot)
2772 
    self._iprot.readMessageEnd()
3431 rajveer 2773 
    if result.success is not None:
1208 chandransh 2774 
      return result.success
3431 rajveer 2775 
    if result.ex is not None:
1208 chandransh 2776 
      raise result.ex
2777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2778 
 
3064 chandransh 2779 
  def verifyOrder(self, orderId):
759 chandransh 2780 
    """
3064 chandransh 2781 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2782 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2783 
    used for all other orders as well.
2784 
    Throws an exception if no such order exists.
3431 rajveer 2785 
 
759 chandransh 2786 
    Parameters:
3064 chandransh 2787 
     - orderId
759 chandransh 2788 
    """
3064 chandransh 2789 
    self.send_verifyOrder(orderId)
2790 
    return self.recv_verifyOrder()
759 chandransh 2791 
 
3064 chandransh 2792 
  def send_verifyOrder(self, orderId):
2793 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2794 
    args = verifyOrder_args()
2795 
    args.orderId = orderId
759 chandransh 2796 
    args.write(self._oprot)
2797 
    self._oprot.writeMessageEnd()
2798 
    self._oprot.trans.flush()
2799 
 
3064 chandransh 2800 
  def recv_verifyOrder(self, ):
759 chandransh 2801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2802 
    if mtype == TMessageType.EXCEPTION:
2803 
      x = TApplicationException()
2804 
      x.read(self._iprot)
2805 
      self._iprot.readMessageEnd()
2806 
      raise x
3064 chandransh 2807 
    result = verifyOrder_result()
759 chandransh 2808 
    result.read(self._iprot)
2809 
    self._iprot.readMessageEnd()
3431 rajveer 2810 
    if result.success is not None:
759 chandransh 2811 
      return result.success
3431 rajveer 2812 
    if result.ex is not None:
759 chandransh 2813 
      raise result.ex
3064 chandransh 2814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2815 
 
3064 chandransh 2816 
  def acceptOrder(self, orderId):
1113 chandransh 2817 
    """
3064 chandransh 2818 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2819 
    given order is not a COD order, it also captures the payment if the same has
2820 
    not been captured.
2821 
    Throws an exception if no such order exists.
3431 rajveer 2822 
 
1113 chandransh 2823 
    Parameters:
3064 chandransh 2824 
     - orderId
1113 chandransh 2825 
    """
3064 chandransh 2826 
    self.send_acceptOrder(orderId)
2827 
    return self.recv_acceptOrder()
1113 chandransh 2828 
 
3064 chandransh 2829 
  def send_acceptOrder(self, orderId):
2830 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2831 
    args = acceptOrder_args()
2832 
    args.orderId = orderId
1113 chandransh 2833 
    args.write(self._oprot)
2834 
    self._oprot.writeMessageEnd()
2835 
    self._oprot.trans.flush()
2836 
 
3064 chandransh 2837 
  def recv_acceptOrder(self, ):
1113 chandransh 2838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2839 
    if mtype == TMessageType.EXCEPTION:
2840 
      x = TApplicationException()
2841 
      x.read(self._iprot)
2842 
      self._iprot.readMessageEnd()
2843 
      raise x
3064 chandransh 2844 
    result = acceptOrder_result()
1113 chandransh 2845 
    result.read(self._iprot)
2846 
    self._iprot.readMessageEnd()
3431 rajveer 2847 
    if result.success is not None:
1113 chandransh 2848 
      return result.success
3431 rajveer 2849 
    if result.ex is not None:
1113 chandransh 2850 
      raise result.ex
3064 chandransh 2851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2852 
 
7190 amar.kumar 2853 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2854 
    """
3064 chandransh 2855 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2856 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2857 
    the IMEI no. if a -1 is supplied.
2858 
    Also, it generates an invoice number for the order, marks the order as
2859 
    BILLED and sets the billing timestamp.
2860 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2861 
 
1135 chandransh 2862 
    Parameters:
3064 chandransh 2863 
     - orderId
2864 
     - invoice_number
4658 mandeep.dh 2865 
     - serialNumber
4283 anupam.sin 2866 
     - itemNumber
7190 amar.kumar 2867 
     - freebieWarehouseId
3064 chandransh 2868 
     - billed_by
4264 rajveer 2869 
     - jacketNumber
4283 anupam.sin 2870 
     - billingType
5110 mandeep.dh 2871 
     - fulfilmentWarehouseId
4763 rajveer 2872 
     - authorize
1135 chandransh 2873 
    """
7190 amar.kumar 2874 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2875 
    return self.recv_addBillingDetails()
1135 chandransh 2876 
 
7190 amar.kumar 2877 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2878 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2879 
    args = addBillingDetails_args()
2880 
    args.orderId = orderId
2881 
    args.invoice_number = invoice_number
4658 mandeep.dh 2882 
    args.serialNumber = serialNumber
4283 anupam.sin 2883 
    args.itemNumber = itemNumber
7190 amar.kumar 2884 
    args.freebieWarehouseId = freebieWarehouseId
3064 chandransh 2885 
    args.billed_by = billed_by
4264 rajveer 2886 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2887 
    args.billingType = billingType
5110 mandeep.dh 2888 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2889 
    args.authorize = authorize
1135 chandransh 2890 
    args.write(self._oprot)
2891 
    self._oprot.writeMessageEnd()
2892 
    self._oprot.trans.flush()
2893 
 
3064 chandransh 2894 
  def recv_addBillingDetails(self, ):
1135 chandransh 2895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2896 
    if mtype == TMessageType.EXCEPTION:
2897 
      x = TApplicationException()
2898 
      x.read(self._iprot)
2899 
      self._iprot.readMessageEnd()
2900 
      raise x
3064 chandransh 2901 
    result = addBillingDetails_result()
1135 chandransh 2902 
    result.read(self._iprot)
2903 
    self._iprot.readMessageEnd()
3431 rajveer 2904 
    if result.success is not None:
3064 chandransh 2905 
      return result.success
3431 rajveer 2906 
    if result.ex is not None:
1135 chandransh 2907 
      raise result.ex
3064 chandransh 2908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2909 
 
6756 amar.kumar 2910 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2911 
    """
2912 
    Add the invoice number to the order.
2913 
 
2914 
    Parameters:
2915 
     - orderId
2916 
     - invoiceNumber
4763 rajveer 2917 
     - color
6756 amar.kumar 2918 
     - serialNumber
2919 
     - itemNumber
4579 rajveer 2920 
    """
6756 amar.kumar 2921 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2922 
    self.recv_addInvoiceNumber()
2923 
 
6756 amar.kumar 2924 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2925 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2926 
    args = addInvoiceNumber_args()
2927 
    args.orderId = orderId
2928 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2929 
    args.color = color
6756 amar.kumar 2930 
    args.serialNumber = serialNumber
2931 
    args.itemNumber = itemNumber
4579 rajveer 2932 
    args.write(self._oprot)
2933 
    self._oprot.writeMessageEnd()
2934 
    self._oprot.trans.flush()
2935 
 
2936 
  def recv_addInvoiceNumber(self, ):
2937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2938 
    if mtype == TMessageType.EXCEPTION:
2939 
      x = TApplicationException()
2940 
      x.read(self._iprot)
2941 
      self._iprot.readMessageEnd()
2942 
      raise x
2943 
    result = addInvoiceNumber_result()
2944 
    result.read(self._iprot)
2945 
    self._iprot.readMessageEnd()
2946 
    if result.ex is not None:
2947 
      raise result.ex
2948 
    return
2949 
 
4910 phani.kuma 2950 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2951 
    """
3064 chandransh 2952 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2953 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2954 
 
1408 ankur.sing 2955 
    Parameters:
3064 chandransh 2956 
     - warehouseId
1408 ankur.sing 2957 
     - providerId
3064 chandransh 2958 
     - cod
4910 phani.kuma 2959 
     - orderIds
1408 ankur.sing 2960 
    """
4910 phani.kuma 2961 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2962 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2963 
 
4910 phani.kuma 2964 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2965 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2966 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2967 
    args.warehouseId = warehouseId
1408 ankur.sing 2968 
    args.providerId = providerId
3064 chandransh 2969 
    args.cod = cod
4910 phani.kuma 2970 
    args.orderIds = orderIds
1408 ankur.sing 2971 
    args.write(self._oprot)
2972 
    self._oprot.writeMessageEnd()
2973 
    self._oprot.trans.flush()
2974 
 
4910 phani.kuma 2975 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2977 
    if mtype == TMessageType.EXCEPTION:
2978 
      x = TApplicationException()
2979 
      x.read(self._iprot)
2980 
      self._iprot.readMessageEnd()
2981 
      raise x
4910 phani.kuma 2982 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2983 
    result.read(self._iprot)
2984 
    self._iprot.readMessageEnd()
3431 rajveer 2985 
    if result.success is not None:
1408 ankur.sing 2986 
      return result.success
3431 rajveer 2987 
    if result.ex is not None:
3064 chandransh 2988 
      raise result.ex
4910 phani.kuma 2989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2990 
 
5713 rajveer 2991 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2992 
    """
2993 
    Parameters:
2994 
     - providerId
2995 
     - orderIds
5713 rajveer 2996 
     - awbs
5676 rajveer 2997 
    """
5713 rajveer 2998 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2999 
    return self.recv_markOrdersAsReturnedFromStore()
3000 
 
5713 rajveer 3001 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 3002 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
3003 
    args = markOrdersAsReturnedFromStore_args()
3004 
    args.providerId = providerId
3005 
    args.orderIds = orderIds
5713 rajveer 3006 
    args.awbs = awbs
5676 rajveer 3007 
    args.write(self._oprot)
3008 
    self._oprot.writeMessageEnd()
3009 
    self._oprot.trans.flush()
3010 
 
3011 
  def recv_markOrdersAsReturnedFromStore(self, ):
3012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3013 
    if mtype == TMessageType.EXCEPTION:
3014 
      x = TApplicationException()
3015 
      x.read(self._iprot)
3016 
      self._iprot.readMessageEnd()
3017 
      raise x
3018 
    result = markOrdersAsReturnedFromStore_result()
3019 
    result.read(self._iprot)
3020 
    self._iprot.readMessageEnd()
3021 
    if result.success is not None:
3022 
      return result.success
3023 
    if result.ex is not None:
3024 
      raise result.ex
3025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
3026 
 
4910 phani.kuma 3027 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 3028 
    """
4910 phani.kuma 3029 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
3030 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 3031 
 
3032 
    Parameters:
3033 
     - providerId
4910 phani.kuma 3034 
     - pickupDetails
4410 rajveer 3035 
    """
4910 phani.kuma 3036 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
3037 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 3038 
 
4910 phani.kuma 3039 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
3040 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3041 
    args = markOrdersAsPickedUp_args()
4410 rajveer 3042 
    args.providerId = providerId
4910 phani.kuma 3043 
    args.pickupDetails = pickupDetails
4410 rajveer 3044 
    args.write(self._oprot)
3045 
    self._oprot.writeMessageEnd()
3046 
    self._oprot.trans.flush()
3047 
 
4910 phani.kuma 3048 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 3049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3050 
    if mtype == TMessageType.EXCEPTION:
3051 
      x = TApplicationException()
3052 
      x.read(self._iprot)
3053 
      self._iprot.readMessageEnd()
3054 
      raise x
4910 phani.kuma 3055 
    result = markOrdersAsPickedUp_result()
4410 rajveer 3056 
    result.read(self._iprot)
3057 
    self._iprot.readMessageEnd()
3058 
    if result.ex is not None:
3059 
      raise result.ex
4910 phani.kuma 3060 
    return
4410 rajveer 3061 
 
4910 phani.kuma 3062 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 3063 
    """
3064 chandransh 3064 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 3065 
 
94 ashish 3066 
    Parameters:
3064 chandransh 3067 
     - providerId
304 ashish 3068 
    """
4910 phani.kuma 3069 
    self.send_getOrdersNotPickedUp(providerId)
3070 
    return self.recv_getOrdersNotPickedUp()
94 ashish 3071 
 
4910 phani.kuma 3072 
  def send_getOrdersNotPickedUp(self, providerId):
3073 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3074 
    args = getOrdersNotPickedUp_args()
3064 chandransh 3075 
    args.providerId = providerId
304 ashish 3076 
    args.write(self._oprot)
3077 
    self._oprot.writeMessageEnd()
3078 
    self._oprot.trans.flush()
3079 
 
4910 phani.kuma 3080 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 3081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3082 
    if mtype == TMessageType.EXCEPTION:
3083 
      x = TApplicationException()
3084 
      x.read(self._iprot)
3085 
      self._iprot.readMessageEnd()
3086 
      raise x
4910 phani.kuma 3087 
    result = getOrdersNotPickedUp_result()
304 ashish 3088 
    result.read(self._iprot)
3089 
    self._iprot.readMessageEnd()
3431 rajveer 3090 
    if result.success is not None:
304 ashish 3091 
      return result.success
4910 phani.kuma 3092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 3093 
 
3064 chandransh 3094 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 3095 
    """
3064 chandransh 3096 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
3097 
    the name of the receiver.
3098 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3099 
 
304 ashish 3100 
    Parameters:
3064 chandransh 3101 
     - providerId
3102 
     - deliveredOrders
304 ashish 3103 
    """
3064 chandransh 3104 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
3105 
    self.recv_markOrdersAsDelivered()
304 ashish 3106 
 
3064 chandransh 3107 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
3108 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
3109 
    args = markOrdersAsDelivered_args()
3110 
    args.providerId = providerId
3111 
    args.deliveredOrders = deliveredOrders
304 ashish 3112 
    args.write(self._oprot)
3113 
    self._oprot.writeMessageEnd()
3114 
    self._oprot.trans.flush()
3115 
 
3064 chandransh 3116 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 3117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3118 
    if mtype == TMessageType.EXCEPTION:
3119 
      x = TApplicationException()
3120 
      x.read(self._iprot)
3121 
      self._iprot.readMessageEnd()
3122 
      raise x
3064 chandransh 3123 
    result = markOrdersAsDelivered_result()
304 ashish 3124 
    result.read(self._iprot)
3125 
    self._iprot.readMessageEnd()
3431 rajveer 3126 
    if result.ex is not None:
3064 chandransh 3127 
      raise result.ex
304 ashish 3128 
    return
3129 
 
4910 phani.kuma 3130 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3131 
    """
4910 phani.kuma 3132 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3133 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3134 
 
3064 chandransh 3135 
    Parameters:
3136 
     - providerId
3137 
     - returnedOrders
1596 ankur.sing 3138 
    """
4910 phani.kuma 3139 
    self.send_markAsRTOrders(providerId, returnedOrders)
3140 
    self.recv_markAsRTOrders()
304 ashish 3141 
 
4910 phani.kuma 3142 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3143 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3144 
    args = markAsRTOrders_args()
3064 chandransh 3145 
    args.providerId = providerId
3146 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3147 
    args.write(self._oprot)
3148 
    self._oprot.writeMessageEnd()
3149 
    self._oprot.trans.flush()
3150 
 
4910 phani.kuma 3151 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3153 
    if mtype == TMessageType.EXCEPTION:
3154 
      x = TApplicationException()
3155 
      x.read(self._iprot)
3156 
      self._iprot.readMessageEnd()
3157 
      raise x
4910 phani.kuma 3158 
    result = markAsRTOrders_result()
1596 ankur.sing 3159 
    result.read(self._iprot)
3160 
    self._iprot.readMessageEnd()
3431 rajveer 3161 
    if result.ex is not None:
3064 chandransh 3162 
      raise result.ex
3163 
    return
1596 ankur.sing 3164 
 
4910 phani.kuma 3165 
  def getRTOrders(self, providerId):
3166 
    """
3167 
    Returns a list of orders that were returned by courier.
3168 
 
3169 
    Parameters:
3170 
     - providerId
3171 
    """
3172 
    self.send_getRTOrders(providerId)
3173 
    return self.recv_getRTOrders()
3174 
 
3175 
  def send_getRTOrders(self, providerId):
3176 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3177 
    args = getRTOrders_args()
3178 
    args.providerId = providerId
3179 
    args.write(self._oprot)
3180 
    self._oprot.writeMessageEnd()
3181 
    self._oprot.trans.flush()
3182 
 
3183 
  def recv_getRTOrders(self, ):
3184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3185 
    if mtype == TMessageType.EXCEPTION:
3186 
      x = TApplicationException()
3187 
      x.read(self._iprot)
3188 
      self._iprot.readMessageEnd()
3189 
      raise x
3190 
    result = getRTOrders_result()
3191 
    result.read(self._iprot)
3192 
    self._iprot.readMessageEnd()
3193 
    if result.success is not None:
3194 
      return result.success
3195 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3196 
 
3064 chandransh 3197 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3198 
    """
3064 chandransh 3199 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3200 
 
3064 chandransh 3201 
    Parameters:
3202 
     - providerId
3203 
     - undeliveredOrders
1627 ankur.sing 3204 
    """
3064 chandransh 3205 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3206 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3207 
 
3064 chandransh 3208 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3209 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3210 
    args = updateNonDeliveryReason_args()
3211 
    args.providerId = providerId
3212 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3213 
    args.write(self._oprot)
3214 
    self._oprot.writeMessageEnd()
3215 
    self._oprot.trans.flush()
3216 
 
3064 chandransh 3217 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3219 
    if mtype == TMessageType.EXCEPTION:
3220 
      x = TApplicationException()
3221 
      x.read(self._iprot)
3222 
      self._iprot.readMessageEnd()
3223 
      raise x
3064 chandransh 3224 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3225 
    result.read(self._iprot)
3226 
    self._iprot.readMessageEnd()
4910 phani.kuma 3227 
    if result.ex is not None:
3228 
      raise result.ex
3229 
    return
3230 
 
3231 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3232 
    """
3233 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3234 
 
3235 
    Parameters:
3236 
     - providerId
3237 
    """
3238 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3239 
    return self.recv_getNonDeliveredOrdersbyCourier()
3240 
 
3241 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3242 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3243 
    args = getNonDeliveredOrdersbyCourier_args()
3244 
    args.providerId = providerId
3245 
    args.write(self._oprot)
3246 
    self._oprot.writeMessageEnd()
3247 
    self._oprot.trans.flush()
3248 
 
3249 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3251 
    if mtype == TMessageType.EXCEPTION:
3252 
      x = TApplicationException()
3253 
      x.read(self._iprot)
3254 
      self._iprot.readMessageEnd()
3255 
      raise x
3256 
    result = getNonDeliveredOrdersbyCourier_result()
3257 
    result.read(self._iprot)
3258 
    self._iprot.readMessageEnd()
4581 phani.kuma 3259 
    if result.success is not None:
3260 
      return result.success
4910 phani.kuma 3261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3262 
 
3263 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3264 
    """
3265 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3266 
 
3267 
    Parameters:
3268 
     - providerId
3269 
     - local_connected_orders
3270 
    """
3271 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3272 
    self.recv_markOrdersAsLocalConnected()
3273 
 
3274 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3275 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3276 
    args = markOrdersAsLocalConnected_args()
3277 
    args.providerId = providerId
3278 
    args.local_connected_orders = local_connected_orders
3279 
    args.write(self._oprot)
3280 
    self._oprot.writeMessageEnd()
3281 
    self._oprot.trans.flush()
3282 
 
3283 
  def recv_markOrdersAsLocalConnected(self, ):
3284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3285 
    if mtype == TMessageType.EXCEPTION:
3286 
      x = TApplicationException()
3287 
      x.read(self._iprot)
3288 
      self._iprot.readMessageEnd()
3289 
      raise x
3290 
    result = markOrdersAsLocalConnected_result()
3291 
    result.read(self._iprot)
3292 
    self._iprot.readMessageEnd()
3431 rajveer 3293 
    if result.ex is not None:
3064 chandransh 3294 
      raise result.ex
4910 phani.kuma 3295 
    return
1627 ankur.sing 3296 
 
4910 phani.kuma 3297 
  def getOrdersNotLocalConnected(self, providerId):
3298 
    """
3299 
    Returns a list of orders that were picked up or shipped but pending local connection.
3300 
 
3301 
    Parameters:
3302 
     - providerId
3303 
    """
3304 
    self.send_getOrdersNotLocalConnected(providerId)
3305 
    return self.recv_getOrdersNotLocalConnected()
3306 
 
3307 
  def send_getOrdersNotLocalConnected(self, providerId):
3308 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3309 
    args = getOrdersNotLocalConnected_args()
3310 
    args.providerId = providerId
3311 
    args.write(self._oprot)
3312 
    self._oprot.writeMessageEnd()
3313 
    self._oprot.trans.flush()
3314 
 
3315 
  def recv_getOrdersNotLocalConnected(self, ):
3316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3317 
    if mtype == TMessageType.EXCEPTION:
3318 
      x = TApplicationException()
3319 
      x.read(self._iprot)
3320 
      self._iprot.readMessageEnd()
3321 
      raise x
3322 
    result = getOrdersNotLocalConnected_result()
3323 
    result.read(self._iprot)
3324 
    self._iprot.readMessageEnd()
3325 
    if result.success is not None:
3326 
      return result.success
3327 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3328 
 
3329 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3330 
    """
3331 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3332 
 
3333 
    Parameters:
3334 
     - providerId
3335 
     - destination_city_reached_orders
3336 
    """
3337 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3338 
    self.recv_markOrdersAsDestinationCityReached()
3339 
 
3340 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3341 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3342 
    args = markOrdersAsDestinationCityReached_args()
3343 
    args.providerId = providerId
3344 
    args.destination_city_reached_orders = destination_city_reached_orders
3345 
    args.write(self._oprot)
3346 
    self._oprot.writeMessageEnd()
3347 
    self._oprot.trans.flush()
3348 
 
3349 
  def recv_markOrdersAsDestinationCityReached(self, ):
3350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3351 
    if mtype == TMessageType.EXCEPTION:
3352 
      x = TApplicationException()
3353 
      x.read(self._iprot)
3354 
      self._iprot.readMessageEnd()
3355 
      raise x
3356 
    result = markOrdersAsDestinationCityReached_result()
3357 
    result.read(self._iprot)
3358 
    self._iprot.readMessageEnd()
3359 
    if result.ex is not None:
3360 
      raise result.ex
3361 
    return
3362 
 
3363 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3364 
    """
3365 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3366 
 
3367 
    Parameters:
3368 
     - providerId
3369 
     - first_atdl_orders
3370 
    """
3371 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3372 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3373 
 
3374 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3375 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3376 
    args = markOrdersAsFirstDeliveryAttempted_args()
3377 
    args.providerId = providerId
3378 
    args.first_atdl_orders = first_atdl_orders
3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = markOrdersAsFirstDeliveryAttempted_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3393 
    if result.ex is not None:
3394 
      raise result.ex
3395 
    return
3396 
 
3064 chandransh 3397 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3398 
    """
3064 chandransh 3399 
    Returns the list of orders whose delivery time has passed but have not been
3400 
    delivered yet for the given provider and warehouse. To get a complete list of
3401 
    undelivered orders, pass them as -1.
3402 
    Returns an empty list if no such orders exist.
3431 rajveer 3403 
 
1886 ankur.sing 3404 
    Parameters:
3064 chandransh 3405 
     - providerId
3406 
     - warehouseId
1886 ankur.sing 3407 
    """
3064 chandransh 3408 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3409 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3410 
 
3064 chandransh 3411 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3412 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3413 
    args = getUndeliveredOrders_args()
3414 
    args.providerId = providerId
3415 
    args.warehouseId = warehouseId
1886 ankur.sing 3416 
    args.write(self._oprot)
3417 
    self._oprot.writeMessageEnd()
3418 
    self._oprot.trans.flush()
3419 
 
3064 chandransh 3420 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3422 
    if mtype == TMessageType.EXCEPTION:
3423 
      x = TApplicationException()
3424 
      x.read(self._iprot)
3425 
      self._iprot.readMessageEnd()
3426 
      raise x
3064 chandransh 3427 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3428 
    result.read(self._iprot)
3429 
    self._iprot.readMessageEnd()
3431 rajveer 3430 
    if result.success is not None:
1886 ankur.sing 3431 
      return result.success
3064 chandransh 3432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3433 
 
4783 phani.kuma 3434 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3435 
    """
3436 
    Returns the list of orders whose expected delivery date has passed but have not been
3437 
    delivered yet.
3438 
    Returns an empty list if no such orders exist.
3439 
    """
3440 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3441 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3442 
 
3443 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3444 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3445 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3446 
    args.write(self._oprot)
3447 
    self._oprot.writeMessageEnd()
3448 
    self._oprot.trans.flush()
3449 
 
3450 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3452 
    if mtype == TMessageType.EXCEPTION:
3453 
      x = TApplicationException()
3454 
      x.read(self._iprot)
3455 
      self._iprot.readMessageEnd()
3456 
      raise x
3457 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3458 
    result.read(self._iprot)
3459 
    self._iprot.readMessageEnd()
3460 
    if result.success is not None:
3461 
      return result.success
3462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3463 
 
2536 chandransh 3464 
  def toggleDOAFlag(self, orderId):
3465 
    """
3466 
    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.
3467 
    Returns the final flag status.
3468 
    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 3469 
 
2536 chandransh 3470 
    Parameters:
3471 
     - orderId
3472 
    """
3473 
    self.send_toggleDOAFlag(orderId)
3474 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3475 
 
2536 chandransh 3476 
  def send_toggleDOAFlag(self, orderId):
3477 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3478 
    args = toggleDOAFlag_args()
3479 
    args.orderId = orderId
3480 
    args.write(self._oprot)
3481 
    self._oprot.writeMessageEnd()
3482 
    self._oprot.trans.flush()
3483 
 
3484 
  def recv_toggleDOAFlag(self, ):
3485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3486 
    if mtype == TMessageType.EXCEPTION:
3487 
      x = TApplicationException()
3488 
      x.read(self._iprot)
3489 
      self._iprot.readMessageEnd()
3490 
      raise x
3491 
    result = toggleDOAFlag_result()
3492 
    result.read(self._iprot)
3493 
    self._iprot.readMessageEnd()
3431 rajveer 3494 
    if result.success is not None:
2536 chandransh 3495 
      return result.success
3431 rajveer 3496 
    if result.ex is not None:
2536 chandransh 3497 
      raise result.ex
3498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3499 
 
4712 rajveer 3500 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3501 
    """
3502 
    Parameters:
3503 
     - orderId
3504 
     - deliveryTimestamp
3505 
     - receiver
3506 
    """
3507 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3508 
    self.recv_markOrderAsDelivered()
3509 
 
3510 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3511 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3512 
    args = markOrderAsDelivered_args()
3513 
    args.orderId = orderId
3514 
    args.deliveryTimestamp = deliveryTimestamp
3515 
    args.receiver = receiver
3516 
    args.write(self._oprot)
3517 
    self._oprot.writeMessageEnd()
3518 
    self._oprot.trans.flush()
3519 
 
3520 
  def recv_markOrderAsDelivered(self, ):
3521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3522 
    if mtype == TMessageType.EXCEPTION:
3523 
      x = TApplicationException()
3524 
      x.read(self._iprot)
3525 
      self._iprot.readMessageEnd()
3526 
      raise x
3527 
    result = markOrderAsDelivered_result()
3528 
    result.read(self._iprot)
3529 
    self._iprot.readMessageEnd()
3530 
    if result.ex is not None:
3531 
      raise result.ex
3532 
    return
3533 
 
5553 rajveer 3534 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3535 
    """
3536 
    Parameters:
3537 
     - orderId
3538 
     - deliveryTimestamp
3539 
    """
3540 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3541 
    self.recv_markOrderAsReceivedAtStore()
3542 
 
3543 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3544 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3545 
    args = markOrderAsReceivedAtStore_args()
3546 
    args.orderId = orderId
3547 
    args.deliveryTimestamp = deliveryTimestamp
3548 
    args.write(self._oprot)
3549 
    self._oprot.writeMessageEnd()
3550 
    self._oprot.trans.flush()
3551 
 
3552 
  def recv_markOrderAsReceivedAtStore(self, ):
3553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3554 
    if mtype == TMessageType.EXCEPTION:
3555 
      x = TApplicationException()
3556 
      x.read(self._iprot)
3557 
      self._iprot.readMessageEnd()
3558 
      raise x
3559 
    result = markOrderAsReceivedAtStore_result()
3560 
    result.read(self._iprot)
3561 
    self._iprot.readMessageEnd()
3562 
    if result.ex is not None:
3563 
      raise result.ex
3564 
    return
3565 
 
4454 rajveer 3566 
  def markOrderDoaRequestReceived(self, orderId):
3567 
    """
3568 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3569 
 
3570 
    Parameters:
3571 
     - orderId
3572 
    """
3573 
    self.send_markOrderDoaRequestReceived(orderId)
3574 
    return self.recv_markOrderDoaRequestReceived()
3575 
 
3576 
  def send_markOrderDoaRequestReceived(self, orderId):
3577 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3578 
    args = markOrderDoaRequestReceived_args()
3579 
    args.orderId = orderId
3580 
    args.write(self._oprot)
3581 
    self._oprot.writeMessageEnd()
3582 
    self._oprot.trans.flush()
3583 
 
3584 
  def recv_markOrderDoaRequestReceived(self, ):
3585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3586 
    if mtype == TMessageType.EXCEPTION:
3587 
      x = TApplicationException()
3588 
      x.read(self._iprot)
3589 
      self._iprot.readMessageEnd()
3590 
      raise x
3591 
    result = markOrderDoaRequestReceived_result()
3592 
    result.read(self._iprot)
3593 
    self._iprot.readMessageEnd()
3594 
    if result.success is not None:
3595 
      return result.success
3596 
    if result.ex is not None:
3597 
      raise result.ex
3598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3599 
 
3600 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3601 
    """
3602 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3603 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3604 
 
3605 
    Parameters:
3606 
     - orderId
3607 
     - isAuthorized
3608 
    """
3609 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3610 
    return self.recv_markOrderDoaRequestAuthorized()
3611 
 
3612 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3613 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3614 
    args = markOrderDoaRequestAuthorized_args()
3615 
    args.orderId = orderId
3616 
    args.isAuthorized = isAuthorized
3617 
    args.write(self._oprot)
3618 
    self._oprot.writeMessageEnd()
3619 
    self._oprot.trans.flush()
3620 
 
3621 
  def recv_markOrderDoaRequestAuthorized(self, ):
3622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3623 
    if mtype == TMessageType.EXCEPTION:
3624 
      x = TApplicationException()
3625 
      x.read(self._iprot)
3626 
      self._iprot.readMessageEnd()
3627 
      raise x
3628 
    result = markOrderDoaRequestAuthorized_result()
3629 
    result.read(self._iprot)
3630 
    self._iprot.readMessageEnd()
3631 
    if result.success is not None:
3632 
      return result.success
3633 
    if result.ex is not None:
3634 
      raise result.ex
3635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3636 
 
4488 rajveer 3637 
  def markOrderReturnRequestReceived(self, orderId):
3638 
    """
3639 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3640 
 
3641 
    Parameters:
3642 
     - orderId
3643 
    """
3644 
    self.send_markOrderReturnRequestReceived(orderId)
3645 
    return self.recv_markOrderReturnRequestReceived()
3646 
 
3647 
  def send_markOrderReturnRequestReceived(self, orderId):
3648 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3649 
    args = markOrderReturnRequestReceived_args()
3650 
    args.orderId = orderId
3651 
    args.write(self._oprot)
3652 
    self._oprot.writeMessageEnd()
3653 
    self._oprot.trans.flush()
3654 
 
3655 
  def recv_markOrderReturnRequestReceived(self, ):
3656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3657 
    if mtype == TMessageType.EXCEPTION:
3658 
      x = TApplicationException()
3659 
      x.read(self._iprot)
3660 
      self._iprot.readMessageEnd()
3661 
      raise x
3662 
    result = markOrderReturnRequestReceived_result()
3663 
    result.read(self._iprot)
3664 
    self._iprot.readMessageEnd()
3665 
    if result.success is not None:
3666 
      return result.success
3667 
    if result.ex is not None:
3668 
      raise result.ex
3669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3670 
 
3671 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3672 
    """
3673 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3674 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3675 
 
3676 
    Parameters:
3677 
     - orderId
3678 
     - isAuthorized
3679 
    """
3680 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3681 
    return self.recv_markOrderReturnRequestAuthorized()
3682 
 
3683 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3684 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3685 
    args = markOrderReturnRequestAuthorized_args()
3686 
    args.orderId = orderId
3687 
    args.isAuthorized = isAuthorized
3688 
    args.write(self._oprot)
3689 
    self._oprot.writeMessageEnd()
3690 
    self._oprot.trans.flush()
3691 
 
3692 
  def recv_markOrderReturnRequestAuthorized(self, ):
3693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3694 
    if mtype == TMessageType.EXCEPTION:
3695 
      x = TApplicationException()
3696 
      x.read(self._iprot)
3697 
      self._iprot.readMessageEnd()
3698 
      raise x
3699 
    result = markOrderReturnRequestAuthorized_result()
3700 
    result.read(self._iprot)
3701 
    self._iprot.readMessageEnd()
3702 
    if result.success is not None:
3703 
      return result.success
3704 
    if result.ex is not None:
3705 
      raise result.ex
3706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3707 
 
4579 rajveer 3708 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3709 
    """
3710 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3711 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3712 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3713 
    For any other status, it returns false.
3714 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3715 
 
2536 chandransh 3716 
    Parameters:
3717 
     - orderId
4579 rajveer 3718 
     - providerId
2536 chandransh 3719 
    """
4579 rajveer 3720 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3721 
    return self.recv_requestPickupNumber()
3722 
 
4579 rajveer 3723 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3724 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3725 
    args = requestPickupNumber_args()
3726 
    args.orderId = orderId
4579 rajveer 3727 
    args.providerId = providerId
2536 chandransh 3728 
    args.write(self._oprot)
3729 
    self._oprot.writeMessageEnd()
3730 
    self._oprot.trans.flush()
3731 
 
3732 
  def recv_requestPickupNumber(self, ):
3733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3734 
    if mtype == TMessageType.EXCEPTION:
3735 
      x = TApplicationException()
3736 
      x.read(self._iprot)
3737 
      self._iprot.readMessageEnd()
3738 
      raise x
3739 
    result = requestPickupNumber_result()
3740 
    result.read(self._iprot)
3741 
    self._iprot.readMessageEnd()
3431 rajveer 3742 
    if result.success is not None:
2536 chandransh 3743 
      return result.success
3431 rajveer 3744 
    if result.ex is not None:
2536 chandransh 3745 
      raise result.ex
3746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3747 
 
4602 rajveer 3748 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3749 
    """
4452 rajveer 3750 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3751 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3752 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3753 
    	3. Returns true
2591 chandransh 3754 
    If the order is in any other status, it returns false.
2536 chandransh 3755 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3756 
 
2536 chandransh 3757 
    Parameters:
3758 
     - orderId
3759 
     - pickupNumber
4602 rajveer 3760 
     - providerId
2536 chandransh 3761 
    """
4602 rajveer 3762 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3763 
    return self.recv_authorizePickup()
3764 
 
4602 rajveer 3765 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3766 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3767 
    args = authorizePickup_args()
3768 
    args.orderId = orderId
3769 
    args.pickupNumber = pickupNumber
4602 rajveer 3770 
    args.providerId = providerId
2536 chandransh 3771 
    args.write(self._oprot)
3772 
    self._oprot.writeMessageEnd()
3773 
    self._oprot.trans.flush()
3774 
 
3775 
  def recv_authorizePickup(self, ):
3776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3777 
    if mtype == TMessageType.EXCEPTION:
3778 
      x = TApplicationException()
3779 
      x.read(self._iprot)
3780 
      self._iprot.readMessageEnd()
3781 
      raise x
3782 
    result = authorizePickup_result()
3783 
    result.read(self._iprot)
3784 
    self._iprot.readMessageEnd()
3431 rajveer 3785 
    if result.success is not None:
2536 chandransh 3786 
      return result.success
3431 rajveer 3787 
    if result.ex is not None:
2536 chandransh 3788 
      raise result.ex
3789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3790 
 
2764 chandransh 3791 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3792 
    """
3793 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3794 
 
2764 chandransh 3795 
    Parameters:
3796 
     - providerId
3797 
     - pickupDetails
3798 
    """
3799 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3800 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3801 
 
3802 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3803 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3804 
    args = markDoasAsPickedUp_args()
3805 
    args.providerId = providerId
3806 
    args.pickupDetails = pickupDetails
3807 
    args.write(self._oprot)
3808 
    self._oprot.writeMessageEnd()
3809 
    self._oprot.trans.flush()
3810 
 
3811 
  def recv_markDoasAsPickedUp(self, ):
3812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3813 
    if mtype == TMessageType.EXCEPTION:
3814 
      x = TApplicationException()
3815 
      x.read(self._iprot)
3816 
      self._iprot.readMessageEnd()
3817 
      raise x
3818 
    result = markDoasAsPickedUp_result()
3819 
    result.read(self._iprot)
3820 
    self._iprot.readMessageEnd()
4910 phani.kuma 3821 
    return
3822 
 
3823 
  def getDoasNotPickedUp(self, providerId):
3824 
    """
3825 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3826 
 
3827 
    Parameters:
3828 
     - providerId
3829 
    """
3830 
    self.send_getDoasNotPickedUp(providerId)
3831 
    return self.recv_getDoasNotPickedUp()
3832 
 
3833 
  def send_getDoasNotPickedUp(self, providerId):
3834 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3835 
    args = getDoasNotPickedUp_args()
3836 
    args.providerId = providerId
3837 
    args.write(self._oprot)
3838 
    self._oprot.writeMessageEnd()
3839 
    self._oprot.trans.flush()
3840 
 
3841 
  def recv_getDoasNotPickedUp(self, ):
3842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3843 
    if mtype == TMessageType.EXCEPTION:
3844 
      x = TApplicationException()
3845 
      x.read(self._iprot)
3846 
      self._iprot.readMessageEnd()
3847 
      raise x
3848 
    result = getDoasNotPickedUp_result()
3849 
    result.read(self._iprot)
3850 
    self._iprot.readMessageEnd()
3431 rajveer 3851 
    if result.success is not None:
2764 chandransh 3852 
      return result.success
4910 phani.kuma 3853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3854 
 
4741 phani.kuma 3855 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3856 
    """
3857 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3858 
 
3859 
    Parameters:
3860 
     - providerId
3861 
     - pickupDetails
3862 
    """
3863 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3864 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3865 
 
3866 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3867 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3868 
    args = markReturnOrdersAsPickedUp_args()
3869 
    args.providerId = providerId
3870 
    args.pickupDetails = pickupDetails
3871 
    args.write(self._oprot)
3872 
    self._oprot.writeMessageEnd()
3873 
    self._oprot.trans.flush()
3874 
 
3875 
  def recv_markReturnOrdersAsPickedUp(self, ):
3876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3877 
    if mtype == TMessageType.EXCEPTION:
3878 
      x = TApplicationException()
3879 
      x.read(self._iprot)
3880 
      self._iprot.readMessageEnd()
3881 
      raise x
3882 
    result = markReturnOrdersAsPickedUp_result()
3883 
    result.read(self._iprot)
3884 
    self._iprot.readMessageEnd()
4910 phani.kuma 3885 
    return
3886 
 
3887 
  def getReturnOrdersNotPickedUp(self, providerId):
3888 
    """
3889 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3890 
 
3891 
    Parameters:
3892 
     - providerId
3893 
    """
3894 
    self.send_getReturnOrdersNotPickedUp(providerId)
3895 
    return self.recv_getReturnOrdersNotPickedUp()
3896 
 
3897 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3898 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3899 
    args = getReturnOrdersNotPickedUp_args()
3900 
    args.providerId = providerId
3901 
    args.write(self._oprot)
3902 
    self._oprot.writeMessageEnd()
3903 
    self._oprot.trans.flush()
3904 
 
3905 
  def recv_getReturnOrdersNotPickedUp(self, ):
3906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3907 
    if mtype == TMessageType.EXCEPTION:
3908 
      x = TApplicationException()
3909 
      x.read(self._iprot)
3910 
      self._iprot.readMessageEnd()
3911 
      raise x
3912 
    result = getReturnOrdersNotPickedUp_result()
3913 
    result.read(self._iprot)
3914 
    self._iprot.readMessageEnd()
4741 phani.kuma 3915 
    if result.success is not None:
3916 
      return result.success
4910 phani.kuma 3917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3918 
 
4479 rajveer 3919 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3920 
    """
4452 rajveer 3921 
    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 3922 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3923 
    If the order is in any other state, it returns false.
3924 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3925 
 
2591 chandransh 3926 
    Parameters:
3927 
     - orderId
4479 rajveer 3928 
     - receiveCondition
2591 chandransh 3929 
    """
4479 rajveer 3930 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3931 
    return self.recv_receiveReturn()
2536 chandransh 3932 
 
4479 rajveer 3933 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3934 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3935 
    args = receiveReturn_args()
2591 chandransh 3936 
    args.orderId = orderId
4479 rajveer 3937 
    args.receiveCondition = receiveCondition
2591 chandransh 3938 
    args.write(self._oprot)
3939 
    self._oprot.writeMessageEnd()
3940 
    self._oprot.trans.flush()
3941 
 
2616 chandransh 3942 
  def recv_receiveReturn(self, ):
2591 chandransh 3943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3944 
    if mtype == TMessageType.EXCEPTION:
3945 
      x = TApplicationException()
3946 
      x.read(self._iprot)
3947 
      self._iprot.readMessageEnd()
3948 
      raise x
2616 chandransh 3949 
    result = receiveReturn_result()
2591 chandransh 3950 
    result.read(self._iprot)
3951 
    self._iprot.readMessageEnd()
3431 rajveer 3952 
    if result.success is not None:
2591 chandransh 3953 
      return result.success
3431 rajveer 3954 
    if result.ex is not None:
2591 chandransh 3955 
      raise result.ex
2616 chandransh 3956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3957 
 
3958 
  def validateDoa(self, orderId, isValid):
3959 
    """
4452 rajveer 3960 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3961 
    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 3962 
    If the order is in any other state, it returns false.
3963 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3964 
 
2591 chandransh 3965 
    Parameters:
3966 
     - orderId
3967 
     - isValid
3968 
    """
3969 
    self.send_validateDoa(orderId, isValid)
3970 
    return self.recv_validateDoa()
3971 
 
3972 
  def send_validateDoa(self, orderId, isValid):
3973 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3974 
    args = validateDoa_args()
3975 
    args.orderId = orderId
3976 
    args.isValid = isValid
3977 
    args.write(self._oprot)
3978 
    self._oprot.writeMessageEnd()
3979 
    self._oprot.trans.flush()
3980 
 
3981 
  def recv_validateDoa(self, ):
3982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3983 
    if mtype == TMessageType.EXCEPTION:
3984 
      x = TApplicationException()
3985 
      x.read(self._iprot)
3986 
      self._iprot.readMessageEnd()
3987 
      raise x
3988 
    result = validateDoa_result()
3989 
    result.read(self._iprot)
3990 
    self._iprot.readMessageEnd()
3431 rajveer 3991 
    if result.success is not None:
2591 chandransh 3992 
      return result.success
3431 rajveer 3993 
    if result.ex is not None:
2591 chandransh 3994 
      raise result.ex
3995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3996 
 
4495 rajveer 3997 
  def validateReturnProduct(self, orderId, isUsable):
3998 
    """
3999 
    Parameters:
4000 
     - orderId
4001 
     - isUsable
4002 
    """
4003 
    self.send_validateReturnProduct(orderId, isUsable)
4004 
    return self.recv_validateReturnProduct()
4005 
 
4006 
  def send_validateReturnProduct(self, orderId, isUsable):
4007 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
4008 
    args = validateReturnProduct_args()
4009 
    args.orderId = orderId
4010 
    args.isUsable = isUsable
4011 
    args.write(self._oprot)
4012 
    self._oprot.writeMessageEnd()
4013 
    self._oprot.trans.flush()
4014 
 
4015 
  def recv_validateReturnProduct(self, ):
4016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4017 
    if mtype == TMessageType.EXCEPTION:
4018 
      x = TApplicationException()
4019 
      x.read(self._iprot)
4020 
      self._iprot.readMessageEnd()
4021 
      raise x
4022 
    result = validateReturnProduct_result()
4023 
    result.read(self._iprot)
4024 
    self._iprot.readMessageEnd()
4025 
    if result.success is not None:
4026 
      return result.success
4027 
    if result.ex is not None:
4028 
      raise result.ex
4029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
4030 
 
2616 chandransh 4031 
  def reshipOrder(self, orderId):
4032 
    """
4484 rajveer 4033 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 4034 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 4035 
    	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 4036 
 
4037 
    If the order is in DOA_CERT_VALID state, it does the following:
4038 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
4039 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 4040 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 4041 
 
2616 chandransh 4042 
    Returns the id of the newly created order.
3431 rajveer 4043 
 
2616 chandransh 4044 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4045 
 
2616 chandransh 4046 
    Parameters:
4047 
     - orderId
4048 
    """
4049 
    self.send_reshipOrder(orderId)
4050 
    return self.recv_reshipOrder()
2591 chandransh 4051 
 
2616 chandransh 4052 
  def send_reshipOrder(self, orderId):
4053 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
4054 
    args = reshipOrder_args()
4055 
    args.orderId = orderId
4056 
    args.write(self._oprot)
4057 
    self._oprot.writeMessageEnd()
4058 
    self._oprot.trans.flush()
4059 
 
4060 
  def recv_reshipOrder(self, ):
4061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4062 
    if mtype == TMessageType.EXCEPTION:
4063 
      x = TApplicationException()
4064 
      x.read(self._iprot)
4065 
      self._iprot.readMessageEnd()
4066 
      raise x
4067 
    result = reshipOrder_result()
4068 
    result.read(self._iprot)
4069 
    self._iprot.readMessageEnd()
3431 rajveer 4070 
    if result.success is not None:
2616 chandransh 4071 
      return result.success
3431 rajveer 4072 
    if result.ex is not None:
2616 chandransh 4073 
      raise result.ex
4074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
4075 
 
3226 chandransh 4076 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4077 
    """
4484 rajveer 4078 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 4079 
    	1. Creates a refund request for batch processing.
4080 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 4081 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 4082 
 
2616 chandransh 4083 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4084 
    	1. Creates a refund request for batch processing.
3226 chandransh 4085 
    	2. Cancels the reservation of the item in the warehouse.
4086 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 4087 
 
3226 chandransh 4088 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4089 
    	1. Cancels the reservation of the item in the warehouse.
4090 
    	2. Marks the current order as CANCELED.
4091 
 
4092 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
4093 
 
2616 chandransh 4094 
    Returns True if it is successful, False otherwise.
3431 rajveer 4095 
 
2616 chandransh 4096 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4097 
 
2616 chandransh 4098 
    Parameters:
4099 
     - orderId
3226 chandransh 4100 
     - refundedBy
4101 
     - reason
2616 chandransh 4102 
    """
3226 chandransh 4103 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 4104 
    return self.recv_refundOrder()
4105 
 
3226 chandransh 4106 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4107 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
4108 
    args = refundOrder_args()
4109 
    args.orderId = orderId
3226 chandransh 4110 
    args.refundedBy = refundedBy
4111 
    args.reason = reason
2616 chandransh 4112 
    args.write(self._oprot)
4113 
    self._oprot.writeMessageEnd()
4114 
    self._oprot.trans.flush()
4115 
 
4116 
  def recv_refundOrder(self, ):
4117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4118 
    if mtype == TMessageType.EXCEPTION:
4119 
      x = TApplicationException()
4120 
      x.read(self._iprot)
4121 
      self._iprot.readMessageEnd()
4122 
      raise x
4123 
    result = refundOrder_result()
4124 
    result.read(self._iprot)
4125 
    self._iprot.readMessageEnd()
3431 rajveer 4126 
    if result.success is not None:
2616 chandransh 4127 
      return result.success
3431 rajveer 4128 
    if result.ex is not None:
2616 chandransh 4129 
      raise result.ex
4130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4131 
 
2690 chandransh 4132 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4133 
    """
4134 
    Get all return orders created between the from and to dates for the given warehouse.
4135 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4136 
 
2690 chandransh 4137 
    Parameters:
4138 
     - warehouseId
4139 
     - fromDate
4140 
     - toDate
4141 
    """
4142 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4143 
    return self.recv_getReturnOrders()
2616 chandransh 4144 
 
2690 chandransh 4145 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4146 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4147 
    args = getReturnOrders_args()
4148 
    args.warehouseId = warehouseId
4149 
    args.fromDate = fromDate
4150 
    args.toDate = toDate
4151 
    args.write(self._oprot)
4152 
    self._oprot.writeMessageEnd()
4153 
    self._oprot.trans.flush()
4154 
 
4155 
  def recv_getReturnOrders(self, ):
4156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4157 
    if mtype == TMessageType.EXCEPTION:
4158 
      x = TApplicationException()
4159 
      x.read(self._iprot)
4160 
      self._iprot.readMessageEnd()
4161 
      raise x
4162 
    result = getReturnOrders_result()
4163 
    result.read(self._iprot)
4164 
    self._iprot.readMessageEnd()
3431 rajveer 4165 
    if result.success is not None:
2690 chandransh 4166 
      return result.success
4167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4168 
 
5481 phani.kuma 4169 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4170 
    """
4171 
    Get all return orders created between the from and to dates.
4172 
 
4173 
    Parameters:
4174 
     - onlyNotProcessed
4175 
     - fromDate
4176 
     - toDate
4177 
    """
4178 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4179 
    return self.recv_getAllReturnOrders()
4180 
 
4181 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4182 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4183 
    args = getAllReturnOrders_args()
4184 
    args.onlyNotProcessed = onlyNotProcessed
4185 
    args.fromDate = fromDate
4186 
    args.toDate = toDate
4187 
    args.write(self._oprot)
4188 
    self._oprot.writeMessageEnd()
4189 
    self._oprot.trans.flush()
4190 
 
4191 
  def recv_getAllReturnOrders(self, ):
4192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4193 
    if mtype == TMessageType.EXCEPTION:
4194 
      x = TApplicationException()
4195 
      x.read(self._iprot)
4196 
      self._iprot.readMessageEnd()
4197 
      raise x
4198 
    result = getAllReturnOrders_result()
4199 
    result.read(self._iprot)
4200 
    self._iprot.readMessageEnd()
4201 
    if result.success is not None:
4202 
      return result.success
4203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4204 
 
2700 chandransh 4205 
  def getReturnOrder(self, id):
4206 
    """
4207 
    Returns the ReturnOrder corresponding to the given id.
4208 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4209 
 
2700 chandransh 4210 
    Parameters:
4211 
     - id
4212 
    """
4213 
    self.send_getReturnOrder(id)
4214 
    return self.recv_getReturnOrder()
4215 
 
4216 
  def send_getReturnOrder(self, id):
4217 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4218 
    args = getReturnOrder_args()
4219 
    args.id = id
4220 
    args.write(self._oprot)
4221 
    self._oprot.writeMessageEnd()
4222 
    self._oprot.trans.flush()
4223 
 
4224 
  def recv_getReturnOrder(self, ):
4225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4226 
    if mtype == TMessageType.EXCEPTION:
4227 
      x = TApplicationException()
4228 
      x.read(self._iprot)
4229 
      self._iprot.readMessageEnd()
4230 
      raise x
4231 
    result = getReturnOrder_result()
4232 
    result.read(self._iprot)
4233 
    self._iprot.readMessageEnd()
3431 rajveer 4234 
    if result.success is not None:
2700 chandransh 4235 
      return result.success
3431 rajveer 4236 
    if result.ex is not None:
2700 chandransh 4237 
      raise result.ex
4238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4239 
 
2690 chandransh 4240 
  def processReturn(self, returnOrderId):
4241 
    """
4242 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4243 
 
2690 chandransh 4244 
    Parameters:
4245 
     - returnOrderId
4246 
    """
4247 
    self.send_processReturn(returnOrderId)
4248 
    self.recv_processReturn()
4249 
 
4250 
  def send_processReturn(self, returnOrderId):
4251 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4252 
    args = processReturn_args()
4253 
    args.returnOrderId = returnOrderId
4254 
    args.write(self._oprot)
4255 
    self._oprot.writeMessageEnd()
4256 
    self._oprot.trans.flush()
4257 
 
4258 
  def recv_processReturn(self, ):
4259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4260 
    if mtype == TMessageType.EXCEPTION:
4261 
      x = TApplicationException()
4262 
      x.read(self._iprot)
4263 
      self._iprot.readMessageEnd()
4264 
      raise x
4265 
    result = processReturn_result()
4266 
    result.read(self._iprot)
4267 
    self._iprot.readMessageEnd()
3431 rajveer 4268 
    if result.ex is not None:
2690 chandransh 4269 
      raise result.ex
4270 
    return
4271 
 
3451 chandransh 4272 
  def updateWeight(self, orderId, weight):
4273 
    """
4274 
    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 4275 
 
3451 chandransh 4276 
    Parameters:
4277 
     - orderId
4278 
     - weight
4279 
    """
4280 
    self.send_updateWeight(orderId, weight)
4281 
    return self.recv_updateWeight()
4282 
 
4283 
  def send_updateWeight(self, orderId, weight):
4284 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4285 
    args = updateWeight_args()
4286 
    args.orderId = orderId
4287 
    args.weight = weight
4288 
    args.write(self._oprot)
4289 
    self._oprot.writeMessageEnd()
4290 
    self._oprot.trans.flush()
4291 
 
4292 
  def recv_updateWeight(self, ):
4293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4294 
    if mtype == TMessageType.EXCEPTION:
4295 
      x = TApplicationException()
4296 
      x.read(self._iprot)
4297 
      self._iprot.readMessageEnd()
4298 
      raise x
4299 
    result = updateWeight_result()
4300 
    result.read(self._iprot)
4301 
    self._iprot.readMessageEnd()
4302 
    if result.success is not None:
4303 
      return result.success
4304 
    if result.ex is not None:
4305 
      raise result.ex
4306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4307 
 
3469 chandransh 4308 
  def changeItem(self, orderId, itemId):
4309 
    """
4310 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4311 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4312 
 
3469 chandransh 4313 
    Parameters:
4314 
     - orderId
4315 
     - itemId
4316 
    """
4317 
    self.send_changeItem(orderId, itemId)
4318 
    return self.recv_changeItem()
4319 
 
4320 
  def send_changeItem(self, orderId, itemId):
4321 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4322 
    args = changeItem_args()
4323 
    args.orderId = orderId
4324 
    args.itemId = itemId
4325 
    args.write(self._oprot)
4326 
    self._oprot.writeMessageEnd()
4327 
    self._oprot.trans.flush()
4328 
 
4329 
  def recv_changeItem(self, ):
4330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4331 
    if mtype == TMessageType.EXCEPTION:
4332 
      x = TApplicationException()
4333 
      x.read(self._iprot)
4334 
      self._iprot.readMessageEnd()
4335 
      raise x
4336 
    result = changeItem_result()
4337 
    result.read(self._iprot)
4338 
    self._iprot.readMessageEnd()
4339 
    if result.success is not None:
4340 
      return result.success
4341 
    if result.ex is not None:
4342 
      raise result.ex
4343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4344 
 
4345 
  def shiftToWarehouse(self, orderId, warehouseId):
4346 
    """
4347 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4348 
 
4349 
    Parameters:
4350 
     - orderId
4351 
     - warehouseId
4352 
    """
4353 
    self.send_shiftToWarehouse(orderId, warehouseId)
4354 
    return self.recv_shiftToWarehouse()
4355 
 
4356 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4357 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4358 
    args = shiftToWarehouse_args()
4359 
    args.orderId = orderId
4360 
    args.warehouseId = warehouseId
4361 
    args.write(self._oprot)
4362 
    self._oprot.writeMessageEnd()
4363 
    self._oprot.trans.flush()
4364 
 
4365 
  def recv_shiftToWarehouse(self, ):
4366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4367 
    if mtype == TMessageType.EXCEPTION:
4368 
      x = TApplicationException()
4369 
      x.read(self._iprot)
4370 
      self._iprot.readMessageEnd()
4371 
      raise x
4372 
    result = shiftToWarehouse_result()
4373 
    result.read(self._iprot)
4374 
    self._iprot.readMessageEnd()
4375 
    if result.success is not None:
4376 
      return result.success
4377 
    if result.ex is not None:
4378 
      raise result.ex
4379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4380 
 
4647 rajveer 4381 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4382 
    """
4383 
    Adds the given delay reason to the given order.
3986 chandransh 4384 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4385 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4386 
 
3553 chandransh 4387 
    Parameters:
4388 
     - orderId
4389 
     - delayReason
3986 chandransh 4390 
     - furtherDelay
4647 rajveer 4391 
     - delayReasonText
3553 chandransh 4392 
    """
4647 rajveer 4393 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4394 
    return self.recv_addDelayReason()
4395 
 
4647 rajveer 4396 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4397 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4398 
    args = addDelayReason_args()
4399 
    args.orderId = orderId
4400 
    args.delayReason = delayReason
3986 chandransh 4401 
    args.furtherDelay = furtherDelay
4647 rajveer 4402 
    args.delayReasonText = delayReasonText
3553 chandransh 4403 
    args.write(self._oprot)
4404 
    self._oprot.writeMessageEnd()
4405 
    self._oprot.trans.flush()
4406 
 
4407 
  def recv_addDelayReason(self, ):
4408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4409 
    if mtype == TMessageType.EXCEPTION:
4410 
      x = TApplicationException()
4411 
      x.read(self._iprot)
4412 
      self._iprot.readMessageEnd()
4413 
      raise x
4414 
    result = addDelayReason_result()
4415 
    result.read(self._iprot)
4416 
    self._iprot.readMessageEnd()
4417 
    if result.success is not None:
4418 
      return result.success
4419 
    if result.ex is not None:
4420 
      raise result.ex
4421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4422 
 
3956 chandransh 4423 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4424 
    """
4425 
    Marks the COD orders with given AWB nos. as having been processed.
4426 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4427 
 
3956 chandransh 4428 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4429 
    1. There is no order corresponding to an AWB number.
4430 
    2. The captured amount for a payment exceeds the total payment.
4431 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4432 
 
4433 
    Parameters:
4434 
     - collectedAmountMap
4435 
     - xferBy
4436 
     - xferTxnId
4437 
     - xferDate
4438 
    """
4439 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4440 
    return self.recv_reconcileCodCollection()
4441 
 
4442 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4443 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4444 
    args = reconcileCodCollection_args()
4445 
    args.collectedAmountMap = collectedAmountMap
4446 
    args.xferBy = xferBy
4447 
    args.xferTxnId = xferTxnId
4448 
    args.xferDate = xferDate
4449 
    args.write(self._oprot)
4450 
    self._oprot.writeMessageEnd()
4451 
    self._oprot.trans.flush()
4452 
 
4453 
  def recv_reconcileCodCollection(self, ):
4454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4455 
    if mtype == TMessageType.EXCEPTION:
4456 
      x = TApplicationException()
4457 
      x.read(self._iprot)
4458 
      self._iprot.readMessageEnd()
4459 
      raise x
4460 
    result = reconcileCodCollection_result()
4461 
    result.read(self._iprot)
4462 
    self._iprot.readMessageEnd()
4463 
    if result.success is not None:
4464 
      return result.success
4465 
    if result.ex is not None:
4466 
      raise result.ex
4467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4468 
 
4008 mandeep.dh 4469 
  def getTransactionsRequiringExtraProcessing(self, category):
4470 
    """
4065 mandeep.dh 4471 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4472 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4473 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4474 
 
4008 mandeep.dh 4475 
    Parameters:
4476 
     - category
4477 
    """
4478 
    self.send_getTransactionsRequiringExtraProcessing(category)
4479 
    return self.recv_getTransactionsRequiringExtraProcessing()
4480 
 
4481 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4482 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4483 
    args = getTransactionsRequiringExtraProcessing_args()
4484 
    args.category = category
4485 
    args.write(self._oprot)
4486 
    self._oprot.writeMessageEnd()
4487 
    self._oprot.trans.flush()
4488 
 
4489 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4491 
    if mtype == TMessageType.EXCEPTION:
4492 
      x = TApplicationException()
4493 
      x.read(self._iprot)
4494 
      self._iprot.readMessageEnd()
4495 
      raise x
4496 
    result = getTransactionsRequiringExtraProcessing_result()
4497 
    result.read(self._iprot)
4498 
    self._iprot.readMessageEnd()
4499 
    if result.success is not None:
4500 
      return result.success
4501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4502 
 
4503 
  def markTransactionAsProcessed(self, transactionId, category):
4504 
    """
4505 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4506 
    It essentially deletes the transaction id record for a particular
4507 
    processing type category (if present) from DB.
4508 
    This is currently used by CRM application.
4008 mandeep.dh 4509 
 
4510 
    Parameters:
4511 
     - transactionId
4512 
     - category
4513 
    """
4514 
    self.send_markTransactionAsProcessed(transactionId, category)
4515 
    self.recv_markTransactionAsProcessed()
4516 
 
4517 
  def send_markTransactionAsProcessed(self, transactionId, category):
4518 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4519 
    args = markTransactionAsProcessed_args()
4520 
    args.transactionId = transactionId
4521 
    args.category = category
4522 
    args.write(self._oprot)
4523 
    self._oprot.writeMessageEnd()
4524 
    self._oprot.trans.flush()
4525 
 
4526 
  def recv_markTransactionAsProcessed(self, ):
4527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4528 
    if mtype == TMessageType.EXCEPTION:
4529 
      x = TApplicationException()
4530 
      x.read(self._iprot)
4531 
      self._iprot.readMessageEnd()
4532 
      raise x
4533 
    result = markTransactionAsProcessed_result()
4534 
    result.read(self._iprot)
4535 
    self._iprot.readMessageEnd()
4536 
    return
4537 
 
4018 chandransh 4538 
  def getItemWiseRiskyOrdersCount(self, ):
4539 
    """
4540 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4541 
    is defined as one whose shipping date is about to expire.
4542 
    """
4543 
    self.send_getItemWiseRiskyOrdersCount()
4544 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4545 
 
4018 chandransh 4546 
  def send_getItemWiseRiskyOrdersCount(self, ):
4547 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4548 
    args = getItemWiseRiskyOrdersCount_args()
4549 
    args.write(self._oprot)
4550 
    self._oprot.writeMessageEnd()
4551 
    self._oprot.trans.flush()
4552 
 
4553 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4555 
    if mtype == TMessageType.EXCEPTION:
4556 
      x = TApplicationException()
4557 
      x.read(self._iprot)
4558 
      self._iprot.readMessageEnd()
4559 
      raise x
4560 
    result = getItemWiseRiskyOrdersCount_result()
4561 
    result.read(self._iprot)
4562 
    self._iprot.readMessageEnd()
4563 
    if result.success is not None:
4564 
      return result.success
4565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4566 
 
4295 varun.gupt 4567 
  def getOrdersForItemIds(self, itemIds):
4568 
    """
4569 
    Returns a list of all orders which have items with given id
4570 
 
4571 
    Parameters:
4572 
     - itemIds
4573 
    """
4574 
    self.send_getOrdersForItemIds(itemIds)
4575 
    return self.recv_getOrdersForItemIds()
4576 
 
4577 
  def send_getOrdersForItemIds(self, itemIds):
4578 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4579 
    args = getOrdersForItemIds_args()
4580 
    args.itemIds = itemIds
4581 
    args.write(self._oprot)
4582 
    self._oprot.writeMessageEnd()
4583 
    self._oprot.trans.flush()
4584 
 
4585 
  def recv_getOrdersForItemIds(self, ):
4586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4587 
    if mtype == TMessageType.EXCEPTION:
4588 
      x = TApplicationException()
4589 
      x.read(self._iprot)
4590 
      self._iprot.readMessageEnd()
4591 
      raise x
4592 
    result = getOrdersForItemIds_result()
4593 
    result.read(self._iprot)
4594 
    self._iprot.readMessageEnd()
4595 
    if result.success is not None:
4596 
      return result.success
4597 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4598 
 
4247 rajveer 4599 
  def markOrderCancellationRequestReceived(self, orderId):
4600 
    """
4601 
    Mark order as cancellation request received. If customer sends request of cancellation of
4602 
    a particular order, this method will be called. It will just change status of the order
4603 
    depending on its current status. It also records the previous status, so that we can move
4604 
    back to that status if cancellation request is denied.
4018 chandransh 4605 
 
4247 rajveer 4606 
    Parameters:
4607 
     - orderId
4608 
    """
4609 
    self.send_markOrderCancellationRequestReceived(orderId)
4610 
    self.recv_markOrderCancellationRequestReceived()
4611 
 
4612 
  def send_markOrderCancellationRequestReceived(self, orderId):
4613 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4614 
    args = markOrderCancellationRequestReceived_args()
4615 
    args.orderId = orderId
4616 
    args.write(self._oprot)
4617 
    self._oprot.writeMessageEnd()
4618 
    self._oprot.trans.flush()
4619 
 
4620 
  def recv_markOrderCancellationRequestReceived(self, ):
4621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4622 
    if mtype == TMessageType.EXCEPTION:
4623 
      x = TApplicationException()
4624 
      x.read(self._iprot)
4625 
      self._iprot.readMessageEnd()
4626 
      raise x
4627 
    result = markOrderCancellationRequestReceived_result()
4628 
    result.read(self._iprot)
4629 
    self._iprot.readMessageEnd()
4630 
    if result.ex is not None:
4631 
      raise result.ex
4632 
    return
4633 
 
4634 
  def markOrderCancellationRequestConfirmed(self, orderId):
4635 
    """
4636 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4637 
    cancellation request confirmed. After this OM will be able to cancel the order.
4638 
 
4639 
    Parameters:
4640 
     - orderId
4641 
    """
4642 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4643 
    self.recv_markOrderCancellationRequestConfirmed()
4644 
 
4645 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4646 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4647 
    args = markOrderCancellationRequestConfirmed_args()
4648 
    args.orderId = orderId
4649 
    args.write(self._oprot)
4650 
    self._oprot.writeMessageEnd()
4651 
    self._oprot.trans.flush()
4652 
 
4653 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4655 
    if mtype == TMessageType.EXCEPTION:
4656 
      x = TApplicationException()
4657 
      x.read(self._iprot)
4658 
      self._iprot.readMessageEnd()
4659 
      raise x
4660 
    result = markOrderCancellationRequestConfirmed_result()
4661 
    result.read(self._iprot)
4662 
    self._iprot.readMessageEnd()
4663 
    if result.ex is not None:
4664 
      raise result.ex
4665 
    return
4666 
 
4667 
  def markOrderCancellationRequestDenied(self, orderId):
4668 
    """
4669 
    If we decide to not to cancel order, we will move the order ro previous status.
4670 
 
4671 
    Parameters:
4672 
     - orderId
4673 
    """
4674 
    self.send_markOrderCancellationRequestDenied(orderId)
4675 
    self.recv_markOrderCancellationRequestDenied()
4676 
 
4677 
  def send_markOrderCancellationRequestDenied(self, orderId):
4678 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4679 
    args = markOrderCancellationRequestDenied_args()
4680 
    args.orderId = orderId
4681 
    args.write(self._oprot)
4682 
    self._oprot.writeMessageEnd()
4683 
    self._oprot.trans.flush()
4684 
 
4685 
  def recv_markOrderCancellationRequestDenied(self, ):
4686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4687 
    if mtype == TMessageType.EXCEPTION:
4688 
      x = TApplicationException()
4689 
      x.read(self._iprot)
4690 
      self._iprot.readMessageEnd()
4691 
      raise x
4692 
    result = markOrderCancellationRequestDenied_result()
4693 
    result.read(self._iprot)
4694 
    self._iprot.readMessageEnd()
4695 
    if result.ex is not None:
4696 
      raise result.ex
4697 
    return
4698 
 
4258 rajveer 4699 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4700 
    """
4258 rajveer 4701 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4702 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4703 
 
4704 
    Parameters:
4258 rajveer 4705 
     - transactionId
4247 rajveer 4706 
    """
4258 rajveer 4707 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4708 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4709 
 
4258 rajveer 4710 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4711 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4712 
    args = markTransactionAsPaymentFlagRemoved_args()
4713 
    args.transactionId = transactionId
4247 rajveer 4714 
    args.write(self._oprot)
4715 
    self._oprot.writeMessageEnd()
4716 
    self._oprot.trans.flush()
4717 
 
4258 rajveer 4718 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4720 
    if mtype == TMessageType.EXCEPTION:
4721 
      x = TApplicationException()
4722 
      x.read(self._iprot)
4723 
      self._iprot.readMessageEnd()
4724 
      raise x
4258 rajveer 4725 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4726 
    result.read(self._iprot)
4727 
    self._iprot.readMessageEnd()
4728 
    if result.ex is not None:
4729 
      raise result.ex
4730 
    return
4731 
 
4259 anupam.sin 4732 
  def refundTransaction(self, transactionId, refundedBy, reason):
4733 
    """
4734 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4735 
    need to be cancelled
4247 rajveer 4736 
 
4259 anupam.sin 4737 
    Parameters:
4738 
     - transactionId
4739 
     - refundedBy
4740 
     - reason
4741 
    """
4742 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4743 
    self.recv_refundTransaction()
4744 
 
4745 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4746 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4747 
    args = refundTransaction_args()
4748 
    args.transactionId = transactionId
4749 
    args.refundedBy = refundedBy
4750 
    args.reason = reason
4751 
    args.write(self._oprot)
4752 
    self._oprot.writeMessageEnd()
4753 
    self._oprot.trans.flush()
4754 
 
4755 
  def recv_refundTransaction(self, ):
4756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4757 
    if mtype == TMessageType.EXCEPTION:
4758 
      x = TApplicationException()
4759 
      x.read(self._iprot)
4760 
      self._iprot.readMessageEnd()
4761 
      raise x
4762 
    result = refundTransaction_result()
4763 
    result.read(self._iprot)
4764 
    self._iprot.readMessageEnd()
4765 
    if result.ex is not None:
4766 
      raise result.ex
4767 
    return
4768 
 
4324 mandeep.dh 4769 
  def updateShipmentAddress(self, orderId, addressId):
4770 
    """
4771 
    Updates shipment address of an order. Delivery and shipping date estimates
4772 
    etc. are also updated here.
4773 
 
4774 
    Throws TransactionServiceException in case address change is not
4775 
    possible due to certain reasons such as new pincode in address is
4776 
    not serviceable etc.
4777 
 
4778 
    Parameters:
4779 
     - orderId
4780 
     - addressId
4781 
    """
4782 
    self.send_updateShipmentAddress(orderId, addressId)
4783 
    self.recv_updateShipmentAddress()
4784 
 
4785 
  def send_updateShipmentAddress(self, orderId, addressId):
4786 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4787 
    args = updateShipmentAddress_args()
4788 
    args.orderId = orderId
4789 
    args.addressId = addressId
4790 
    args.write(self._oprot)
4791 
    self._oprot.writeMessageEnd()
4792 
    self._oprot.trans.flush()
4793 
 
4794 
  def recv_updateShipmentAddress(self, ):
4795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4796 
    if mtype == TMessageType.EXCEPTION:
4797 
      x = TApplicationException()
4798 
      x.read(self._iprot)
4799 
      self._iprot.readMessageEnd()
4800 
      raise x
4801 
    result = updateShipmentAddress_result()
4802 
    result.read(self._iprot)
4803 
    self._iprot.readMessageEnd()
4804 
    if result.ex is not None:
4805 
      raise result.ex
4806 
    return
4807 
 
4285 rajveer 4808 
  def acceptOrdersForItemId(self, itemId, inventory):
4809 
    """
4810 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4811 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4812 
 
4285 rajveer 4813 
    Parameters:
4814 
     - itemId
4815 
     - inventory
4816 
    """
4817 
    self.send_acceptOrdersForItemId(itemId, inventory)
4818 
    return self.recv_acceptOrdersForItemId()
4819 
 
4820 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4821 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4822 
    args = acceptOrdersForItemId_args()
4823 
    args.itemId = itemId
4824 
    args.inventory = inventory
4825 
    args.write(self._oprot)
4826 
    self._oprot.writeMessageEnd()
4827 
    self._oprot.trans.flush()
4828 
 
4829 
  def recv_acceptOrdersForItemId(self, ):
4830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4831 
    if mtype == TMessageType.EXCEPTION:
4832 
      x = TApplicationException()
4833 
      x.read(self._iprot)
4834 
      self._iprot.readMessageEnd()
4835 
      raise x
4836 
    result = acceptOrdersForItemId_result()
4837 
    result.read(self._iprot)
4838 
    self._iprot.readMessageEnd()
4839 
    if result.success is not None:
4840 
      return result.success
4841 
    if result.ex is not None:
4842 
      raise result.ex
4843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4844 
 
4369 rajveer 4845 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4846 
    """
4847 
    Parameters:
4848 
     - vendorId
4849 
     - itemId
4850 
     - quantity
4851 
     - estimate
4369 rajveer 4852 
     - isReminder
4303 rajveer 4853 
    """
4369 rajveer 4854 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4855 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4856 
 
4369 rajveer 4857 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4858 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4859 
    args = markOrdersAsPORaised_args()
4860 
    args.vendorId = vendorId
4861 
    args.itemId = itemId
4862 
    args.quantity = quantity
4863 
    args.estimate = estimate
4369 rajveer 4864 
    args.isReminder = isReminder
4303 rajveer 4865 
    args.write(self._oprot)
4866 
    self._oprot.writeMessageEnd()
4867 
    self._oprot.trans.flush()
4868 
 
4869 
  def recv_markOrdersAsPORaised(self, ):
4870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4871 
    if mtype == TMessageType.EXCEPTION:
4872 
      x = TApplicationException()
4873 
      x.read(self._iprot)
4874 
      self._iprot.readMessageEnd()
4875 
      raise x
4876 
    result = markOrdersAsPORaised_result()
4877 
    result.read(self._iprot)
4878 
    self._iprot.readMessageEnd()
4879 
    if result.ex is not None:
4880 
      raise result.ex
4881 
    return
4882 
 
4369 rajveer 4883 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4884 
    """
4885 
    Parameters:
4886 
     - vendorId
4887 
     - itemId
4888 
     - quantity
4889 
     - estimate
4369 rajveer 4890 
     - isReminder
4303 rajveer 4891 
    """
4369 rajveer 4892 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4893 
    self.recv_markOrdersAsReversalInitiated()
4894 
 
4369 rajveer 4895 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4896 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4897 
    args = markOrdersAsReversalInitiated_args()
4898 
    args.vendorId = vendorId
4899 
    args.itemId = itemId
4900 
    args.quantity = quantity
4901 
    args.estimate = estimate
4369 rajveer 4902 
    args.isReminder = isReminder
4303 rajveer 4903 
    args.write(self._oprot)
4904 
    self._oprot.writeMessageEnd()
4905 
    self._oprot.trans.flush()
4906 
 
4907 
  def recv_markOrdersAsReversalInitiated(self, ):
4908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4909 
    if mtype == TMessageType.EXCEPTION:
4910 
      x = TApplicationException()
4911 
      x.read(self._iprot)
4912 
      self._iprot.readMessageEnd()
4913 
      raise x
4914 
    result = markOrdersAsReversalInitiated_result()
4915 
    result.read(self._iprot)
4916 
    self._iprot.readMessageEnd()
4917 
    if result.ex is not None:
4918 
      raise result.ex
4919 
    return
4920 
 
4369 rajveer 4921 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4922 
    """
4923 
    Parameters:
4924 
     - vendorId
4925 
     - itemId
4926 
     - quantity
4927 
     - estimate
4369 rajveer 4928 
     - isReminder
4303 rajveer 4929 
    """
4369 rajveer 4930 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4931 
    self.recv_markOrdersAsNotAvailabke()
4932 
 
4369 rajveer 4933 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4934 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4935 
    args = markOrdersAsNotAvailabke_args()
4936 
    args.vendorId = vendorId
4937 
    args.itemId = itemId
4938 
    args.quantity = quantity
4939 
    args.estimate = estimate
4369 rajveer 4940 
    args.isReminder = isReminder
4303 rajveer 4941 
    args.write(self._oprot)
4942 
    self._oprot.writeMessageEnd()
4943 
    self._oprot.trans.flush()
4944 
 
4945 
  def recv_markOrdersAsNotAvailabke(self, ):
4946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4947 
    if mtype == TMessageType.EXCEPTION:
4948 
      x = TApplicationException()
4949 
      x.read(self._iprot)
4950 
      self._iprot.readMessageEnd()
4951 
      raise x
4952 
    result = markOrdersAsNotAvailabke_result()
4953 
    result.read(self._iprot)
4954 
    self._iprot.readMessageEnd()
4955 
    if result.ex is not None:
4956 
      raise result.ex
4957 
    return
4958 
 
4369 rajveer 4959 
  def markOrdersAsTimeout(self, vendorId):
4960 
    """
4961 
    Parameters:
4962 
     - vendorId
4963 
    """
4964 
    self.send_markOrdersAsTimeout(vendorId)
4965 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4966 
 
4369 rajveer 4967 
  def send_markOrdersAsTimeout(self, vendorId):
4968 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4969 
    args = markOrdersAsTimeout_args()
4970 
    args.vendorId = vendorId
4971 
    args.write(self._oprot)
4972 
    self._oprot.writeMessageEnd()
4973 
    self._oprot.trans.flush()
4974 
 
4975 
  def recv_markOrdersAsTimeout(self, ):
4976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4977 
    if mtype == TMessageType.EXCEPTION:
4978 
      x = TApplicationException()
4979 
      x.read(self._iprot)
4980 
      self._iprot.readMessageEnd()
4981 
      raise x
4982 
    result = markOrdersAsTimeout_result()
4983 
    result.read(self._iprot)
4984 
    self._iprot.readMessageEnd()
4985 
    if result.success is not None:
4986 
      return result.success
4987 
    if result.ex is not None:
4988 
      raise result.ex
4989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4990 
 
4662 rajveer 4991 
  def markOrderAsLostInTransit(self, orderId):
4992 
    """
4993 
    Mark order as LOST_IN_TRANSIT
4994 
 
4995 
    Parameters:
4996 
     - orderId
4997 
    """
4998 
    self.send_markOrderAsLostInTransit(orderId)
4999 
    return self.recv_markOrderAsLostInTransit()
5000 
 
5001 
  def send_markOrderAsLostInTransit(self, orderId):
5002 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
5003 
    args = markOrderAsLostInTransit_args()
5004 
    args.orderId = orderId
5005 
    args.write(self._oprot)
5006 
    self._oprot.writeMessageEnd()
5007 
    self._oprot.trans.flush()
5008 
 
5009 
  def recv_markOrderAsLostInTransit(self, ):
5010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5011 
    if mtype == TMessageType.EXCEPTION:
5012 
      x = TApplicationException()
5013 
      x.read(self._iprot)
5014 
      self._iprot.readMessageEnd()
5015 
      raise x
5016 
    result = markOrderAsLostInTransit_result()
5017 
    result.read(self._iprot)
5018 
    self._iprot.readMessageEnd()
5019 
    if result.success is not None:
5020 
      return result.success
5021 
    if result.ex is not None:
5022 
      raise result.ex
5023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
5024 
 
4386 anupam.sin 5025 
  def getOrderForAwb(self, awb):
5026 
    """
5027 
    Returns the order corresponding to an AWB number
4369 rajveer 5028 
 
4386 anupam.sin 5029 
    Parameters:
5030 
     - awb
5031 
    """
5032 
    self.send_getOrderForAwb(awb)
5033 
    return self.recv_getOrderForAwb()
5034 
 
5035 
  def send_getOrderForAwb(self, awb):
5036 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
5037 
    args = getOrderForAwb_args()
5038 
    args.awb = awb
5039 
    args.write(self._oprot)
5040 
    self._oprot.writeMessageEnd()
5041 
    self._oprot.trans.flush()
5042 
 
5043 
  def recv_getOrderForAwb(self, ):
5044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5045 
    if mtype == TMessageType.EXCEPTION:
5046 
      x = TApplicationException()
5047 
      x.read(self._iprot)
5048 
      self._iprot.readMessageEnd()
5049 
      raise x
5050 
    result = getOrderForAwb_result()
5051 
    result.read(self._iprot)
5052 
    self._iprot.readMessageEnd()
5053 
    if result.success is not None:
5054 
      return result.success
5055 
    if result.ex is not None:
5056 
      raise result.ex
5057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
5058 
 
4910 phani.kuma 5059 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 5060 
    """
4910 phani.kuma 5061 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 5062 
 
4506 phani.kuma 5063 
    Parameters:
5064 
     - logistics_provider_id
4910 phani.kuma 5065 
     - order_status_list
4506 phani.kuma 5066 
    """
4910 phani.kuma 5067 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 5068 
    return self.recv_getOrdersForProviderForStatus()
5069 
 
4910 phani.kuma 5070 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 5071 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
5072 
    args = getOrdersForProviderForStatus_args()
5073 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 5074 
    args.order_status_list = order_status_list
4506 phani.kuma 5075 
    args.write(self._oprot)
5076 
    self._oprot.writeMessageEnd()
5077 
    self._oprot.trans.flush()
5078 
 
5079 
  def recv_getOrdersForProviderForStatus(self, ):
5080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5081 
    if mtype == TMessageType.EXCEPTION:
5082 
      x = TApplicationException()
5083 
      x.read(self._iprot)
5084 
      self._iprot.readMessageEnd()
5085 
      raise x
5086 
    result = getOrdersForProviderForStatus_result()
5087 
    result.read(self._iprot)
5088 
    self._iprot.readMessageEnd()
5089 
    if result.success is not None:
5090 
      return result.success
5091 
    if result.ex is not None:
5092 
      raise result.ex
5093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
5094 
 
4600 varun.gupt 5095 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5096 
    """
5097 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 5098 
 
4600 varun.gupt 5099 
    Parameters:
5100 
     - vendorId
5101 
     - billingDateFrom
5102 
     - billingDateTo
5103 
    """
5104 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
5105 
    return self.recv_getBilledOrdersForVendor()
5106 
 
5107 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5108 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
5109 
    args = getBilledOrdersForVendor_args()
5110 
    args.vendorId = vendorId
5111 
    args.billingDateFrom = billingDateFrom
5112 
    args.billingDateTo = billingDateTo
5113 
    args.write(self._oprot)
5114 
    self._oprot.writeMessageEnd()
5115 
    self._oprot.trans.flush()
5116 
 
5117 
  def recv_getBilledOrdersForVendor(self, ):
5118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5119 
    if mtype == TMessageType.EXCEPTION:
5120 
      x = TApplicationException()
5121 
      x.read(self._iprot)
5122 
      self._iprot.readMessageEnd()
5123 
      raise x
5124 
    result = getBilledOrdersForVendor_result()
5125 
    result.read(self._iprot)
5126 
    self._iprot.readMessageEnd()
5127 
    if result.success is not None:
5128 
      return result.success
5129 
    if result.ex is not None:
5130 
      raise result.ex
5131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5132 
 
4607 rajveer 5133 
  def getSlippedSippingDateOrders(self, ):
5134 
    self.send_getSlippedSippingDateOrders()
5135 
    return self.recv_getSlippedSippingDateOrders()
5136 
 
5137 
  def send_getSlippedSippingDateOrders(self, ):
5138 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5139 
    args = getSlippedSippingDateOrders_args()
5140 
    args.write(self._oprot)
5141 
    self._oprot.writeMessageEnd()
5142 
    self._oprot.trans.flush()
5143 
 
5144 
  def recv_getSlippedSippingDateOrders(self, ):
5145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5146 
    if mtype == TMessageType.EXCEPTION:
5147 
      x = TApplicationException()
5148 
      x.read(self._iprot)
5149 
      self._iprot.readMessageEnd()
5150 
      raise x
5151 
    result = getSlippedSippingDateOrders_result()
5152 
    result.read(self._iprot)
5153 
    self._iprot.readMessageEnd()
5154 
    if result.success is not None:
5155 
      return result.success
5156 
    if result.ex is not None:
5157 
      raise result.ex
5158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5159 
 
4709 rajveer 5160 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5161 
    """
5162 
    Parameters:
5163 
     - cancelDateFrom
5164 
     - cancelDateTo
5165 
    """
5166 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5167 
    return self.recv_getCancelledOrders()
5168 
 
5169 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5170 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5171 
    args = getCancelledOrders_args()
5172 
    args.cancelDateFrom = cancelDateFrom
5173 
    args.cancelDateTo = cancelDateTo
5174 
    args.write(self._oprot)
5175 
    self._oprot.writeMessageEnd()
5176 
    self._oprot.trans.flush()
5177 
 
5178 
  def recv_getCancelledOrders(self, ):
5179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5180 
    if mtype == TMessageType.EXCEPTION:
5181 
      x = TApplicationException()
5182 
      x.read(self._iprot)
5183 
      self._iprot.readMessageEnd()
5184 
      raise x
5185 
    result = getCancelledOrders_result()
5186 
    result.read(self._iprot)
5187 
    self._iprot.readMessageEnd()
5188 
    if result.success is not None:
5189 
      return result.success
5190 
    if result.ex is not None:
5191 
      raise result.ex
5192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5193 
 
4600 varun.gupt 5194 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5195 
    """
5196 
    Parameters:
5197 
     - mapAWBAndAmount
5198 
    """
5199 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5200 
    self.recv_saveBluedartSettlements()
5201 
 
5202 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5203 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5204 
    args = saveBluedartSettlements_args()
5205 
    args.mapAWBAndAmount = mapAWBAndAmount
5206 
    args.write(self._oprot)
5207 
    self._oprot.writeMessageEnd()
5208 
    self._oprot.trans.flush()
5209 
 
5210 
  def recv_saveBluedartSettlements(self, ):
5211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5212 
    if mtype == TMessageType.EXCEPTION:
5213 
      x = TApplicationException()
5214 
      x.read(self._iprot)
5215 
      self._iprot.readMessageEnd()
5216 
      raise x
5217 
    result = saveBluedartSettlements_result()
5218 
    result.read(self._iprot)
5219 
    self._iprot.readMessageEnd()
5220 
    if result.ex is not None:
5221 
      raise result.ex
5222 
    return
5223 
 
4905 varun.gupt 5224 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5225 
    """
5226 
    Parameters:
5227 
     - settlementDate
5228 
     - paymentGatewayId
4905 varun.gupt 5229 
     - referenceId
4600 varun.gupt 5230 
     - serviceTax
5231 
     - otherCharges
5232 
     - netCollection
5233 
    """
4905 varun.gupt 5234 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5235 
    self.recv_savePaymentSettlements()
5236 
 
4905 varun.gupt 5237 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5238 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5239 
    args = savePaymentSettlements_args()
5240 
    args.settlementDate = settlementDate
5241 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5242 
    args.referenceId = referenceId
4600 varun.gupt 5243 
    args.serviceTax = serviceTax
5244 
    args.otherCharges = otherCharges
5245 
    args.netCollection = netCollection
5246 
    args.write(self._oprot)
5247 
    self._oprot.writeMessageEnd()
5248 
    self._oprot.trans.flush()
5249 
 
5250 
  def recv_savePaymentSettlements(self, ):
5251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5252 
    if mtype == TMessageType.EXCEPTION:
5253 
      x = TApplicationException()
5254 
      x.read(self._iprot)
5255 
      self._iprot.readMessageEnd()
5256 
      raise x
5257 
    result = savePaymentSettlements_result()
5258 
    result.read(self._iprot)
5259 
    self._iprot.readMessageEnd()
5260 
    if result.ex is not None:
5261 
      raise result.ex
5262 
    return
5263 
 
5264 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5265 
    """
5266 
    Parameters:
5267 
     - settlementId
5268 
     - settlementDate
5269 
     - transactionDateFrom
5270 
     - transactionDateTo
5271 
     - amount
5272 
    """
5273 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5274 
    self.recv_saveEBSSettlementSummary()
5275 
 
5276 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5277 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5278 
    args = saveEBSSettlementSummary_args()
5279 
    args.settlementId = settlementId
5280 
    args.settlementDate = settlementDate
5281 
    args.transactionDateFrom = transactionDateFrom
5282 
    args.transactionDateTo = transactionDateTo
5283 
    args.amount = amount
5284 
    args.write(self._oprot)
5285 
    self._oprot.writeMessageEnd()
5286 
    self._oprot.trans.flush()
5287 
 
5288 
  def recv_saveEBSSettlementSummary(self, ):
5289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5290 
    if mtype == TMessageType.EXCEPTION:
5291 
      x = TApplicationException()
5292 
      x.read(self._iprot)
5293 
      self._iprot.readMessageEnd()
5294 
      raise x
5295 
    result = saveEBSSettlementSummary_result()
5296 
    result.read(self._iprot)
5297 
    self._iprot.readMessageEnd()
5298 
    if result.ex is not None:
5299 
      raise result.ex
5300 
    return
5301 
 
5386 phani.kuma 5302 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5303 
    """
5304 
    Parameters:
5189 varun.gupt 5305 
     - referenceId
5306 
     - isRefund
4600 varun.gupt 5307 
    """
5386 phani.kuma 5308 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5309 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5310 
 
5386 phani.kuma 5311 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5312 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5313 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5314 
    args.referenceId = referenceId
5315 
    args.isRefund = isRefund
4600 varun.gupt 5316 
    args.write(self._oprot)
5317 
    self._oprot.writeMessageEnd()
5318 
    self._oprot.trans.flush()
5319 
 
5386 phani.kuma 5320 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5322 
    if mtype == TMessageType.EXCEPTION:
5323 
      x = TApplicationException()
5324 
      x.read(self._iprot)
5325 
      self._iprot.readMessageEnd()
5326 
      raise x
5386 phani.kuma 5327 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5328 
    result.read(self._iprot)
5329 
    self._iprot.readMessageEnd()
5330 
    if result.success is not None:
5331 
      return result.success
5332 
    if result.ex is not None:
5333 
      raise result.ex
5386 phani.kuma 5334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5335 
 
5386 phani.kuma 5336 
  def getSettlementForCod(self, orderId, isRefund):
5337 
    """
5338 
    Parameters:
5339 
     - orderId
5340 
     - isRefund
5341 
    """
5342 
    self.send_getSettlementForCod(orderId, isRefund)
5343 
    return self.recv_getSettlementForCod()
5344 
 
5345 
  def send_getSettlementForCod(self, orderId, isRefund):
5346 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5347 
    args = getSettlementForCod_args()
5348 
    args.orderId = orderId
5349 
    args.isRefund = isRefund
5350 
    args.write(self._oprot)
5351 
    self._oprot.writeMessageEnd()
5352 
    self._oprot.trans.flush()
5353 
 
5354 
  def recv_getSettlementForCod(self, ):
5355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5356 
    if mtype == TMessageType.EXCEPTION:
5357 
      x = TApplicationException()
5358 
      x.read(self._iprot)
5359 
      self._iprot.readMessageEnd()
5360 
      raise x
5361 
    result = getSettlementForCod_result()
5362 
    result.read(self._iprot)
5363 
    self._iprot.readMessageEnd()
5364 
    if result.success is not None:
5365 
      return result.success
5366 
    if result.ex is not None:
5367 
      raise result.ex
5368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5369 
 
4600 varun.gupt 5370 
  def getEBSSettlementSummaries(self, ):
5371 
    self.send_getEBSSettlementSummaries()
5372 
    return self.recv_getEBSSettlementSummaries()
5373 
 
5374 
  def send_getEBSSettlementSummaries(self, ):
5375 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5376 
    args = getEBSSettlementSummaries_args()
5377 
    args.write(self._oprot)
5378 
    self._oprot.writeMessageEnd()
5379 
    self._oprot.trans.flush()
5380 
 
5381 
  def recv_getEBSSettlementSummaries(self, ):
5382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5383 
    if mtype == TMessageType.EXCEPTION:
5384 
      x = TApplicationException()
5385 
      x.read(self._iprot)
5386 
      self._iprot.readMessageEnd()
5387 
      raise x
5388 
    result = getEBSSettlementSummaries_result()
5389 
    result.read(self._iprot)
5390 
    self._iprot.readMessageEnd()
5391 
    if result.success is not None:
5392 
      return result.success
5393 
    if result.ex is not None:
5394 
      raise result.ex
5395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5396 
 
5397 
  def markEBSSettlementUploaded(self, settlementId):
5398 
    """
5399 
    Parameters:
5400 
     - settlementId
5401 
    """
5402 
    self.send_markEBSSettlementUploaded(settlementId)
5403 
    self.recv_markEBSSettlementUploaded()
5404 
 
5405 
  def send_markEBSSettlementUploaded(self, settlementId):
5406 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5407 
    args = markEBSSettlementUploaded_args()
5408 
    args.settlementId = settlementId
5409 
    args.write(self._oprot)
5410 
    self._oprot.writeMessageEnd()
5411 
    self._oprot.trans.flush()
5412 
 
5413 
  def recv_markEBSSettlementUploaded(self, ):
5414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5415 
    if mtype == TMessageType.EXCEPTION:
5416 
      x = TApplicationException()
5417 
      x.read(self._iprot)
5418 
      self._iprot.readMessageEnd()
5419 
      raise x
5420 
    result = markEBSSettlementUploaded_result()
5421 
    result.read(self._iprot)
5422 
    self._iprot.readMessageEnd()
5423 
    if result.ex is not None:
5424 
      raise result.ex
5425 
    return
5426 
 
5427 
  def getEBSSettlementDate(self, settlementId):
5428 
    """
5429 
    Parameters:
5430 
     - settlementId
5431 
    """
5432 
    self.send_getEBSSettlementDate(settlementId)
5433 
    return self.recv_getEBSSettlementDate()
5434 
 
5435 
  def send_getEBSSettlementDate(self, settlementId):
5436 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5437 
    args = getEBSSettlementDate_args()
5438 
    args.settlementId = settlementId
5439 
    args.write(self._oprot)
5440 
    self._oprot.writeMessageEnd()
5441 
    self._oprot.trans.flush()
5442 
 
5443 
  def recv_getEBSSettlementDate(self, ):
5444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5445 
    if mtype == TMessageType.EXCEPTION:
5446 
      x = TApplicationException()
5447 
      x.read(self._iprot)
5448 
      self._iprot.readMessageEnd()
5449 
      raise x
5450 
    result = getEBSSettlementDate_result()
5451 
    result.read(self._iprot)
5452 
    self._iprot.readMessageEnd()
5453 
    if result.success is not None:
5454 
      return result.success
5455 
    if result.ex is not None:
5456 
      raise result.ex
5457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5458 
 
4715 varun.gupt 5459 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5460 
    """
5461 
    Parameters:
5462 
     - settlementDateFrom
5463 
     - settlementDateTo
5464 
     - isRefund
5465 
    """
5466 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5467 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5468 
 
4715 varun.gupt 5469 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5470 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5471 
    args = getSettlementsByDate_args()
5472 
    args.settlementDateFrom = settlementDateFrom
5473 
    args.settlementDateTo = settlementDateTo
5474 
    args.isRefund = isRefund
5475 
    args.write(self._oprot)
5476 
    self._oprot.writeMessageEnd()
5477 
    self._oprot.trans.flush()
5478 
 
5479 
  def recv_getSettlementsByDate(self, ):
5480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5481 
    if mtype == TMessageType.EXCEPTION:
5482 
      x = TApplicationException()
5483 
      x.read(self._iprot)
5484 
      self._iprot.readMessageEnd()
5485 
      raise x
5486 
    result = getSettlementsByDate_result()
5487 
    result.read(self._iprot)
5488 
    self._iprot.readMessageEnd()
5489 
    if result.success is not None:
5490 
      return result.success
5491 
    if result.ex is not None:
5492 
      raise result.ex
5493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5494 
 
5495 
  def getReshippedOrderIds(self, orderIds):
5496 
    """
5497 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5498 
 
5499 
    Parameters:
5500 
     - orderIds
5501 
    """
5502 
    self.send_getReshippedOrderIds(orderIds)
5503 
    return self.recv_getReshippedOrderIds()
5504 
 
5505 
  def send_getReshippedOrderIds(self, orderIds):
5506 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5507 
    args = getReshippedOrderIds_args()
5508 
    args.orderIds = orderIds
5509 
    args.write(self._oprot)
5510 
    self._oprot.writeMessageEnd()
5511 
    self._oprot.trans.flush()
5512 
 
5513 
  def recv_getReshippedOrderIds(self, ):
5514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5515 
    if mtype == TMessageType.EXCEPTION:
5516 
      x = TApplicationException()
5517 
      x.read(self._iprot)
5518 
      self._iprot.readMessageEnd()
5519 
      raise x
5520 
    result = getReshippedOrderIds_result()
5521 
    result.read(self._iprot)
5522 
    self._iprot.readMessageEnd()
5523 
    if result.success is not None:
5524 
      return result.success
5525 
    if result.ex is not None:
5526 
      raise result.ex
5527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5528 
 
5481 phani.kuma 5529 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5530 
    """
5531 
    Parameters:
5532 
     - vendorId
5481 phani.kuma 5533 
     - onlyVendorNotPaid
5534 
     - billingDateFrom
5535 
     - billingDateTo
4875 varun.gupt 5536 
    """
5481 phani.kuma 5537 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5538 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5539 
 
5481 phani.kuma 5540 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5541 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5542 
    args = getBilledOrders_args()
4875 varun.gupt 5543 
    args.vendorId = vendorId
5481 phani.kuma 5544 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5545 
    args.billingDateFrom = billingDateFrom
5546 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5547 
    args.write(self._oprot)
5548 
    self._oprot.writeMessageEnd()
5549 
    self._oprot.trans.flush()
5550 
 
5481 phani.kuma 5551 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5553 
    if mtype == TMessageType.EXCEPTION:
5554 
      x = TApplicationException()
5555 
      x.read(self._iprot)
5556 
      self._iprot.readMessageEnd()
5557 
      raise x
5481 phani.kuma 5558 
    result = getBilledOrders_result()
4875 varun.gupt 5559 
    result.read(self._iprot)
5560 
    self._iprot.readMessageEnd()
5561 
    if result.success is not None:
5562 
      return result.success
5563 
    if result.ex is not None:
5564 
      raise result.ex
5481 phani.kuma 5565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5566 
 
5031 varun.gupt 5567 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5568 
    """
5569 
    Parameters:
5570 
     - startDate
5571 
     - endDate
5572 
    """
5573 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5574 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5575 
 
5031 varun.gupt 5576 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5577 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5578 
    args = getStatusDistributionOfOrders_args()
5579 
    args.startDate = startDate
5580 
    args.endDate = endDate
5581 
    args.write(self._oprot)
5582 
    self._oprot.writeMessageEnd()
5583 
    self._oprot.trans.flush()
5584 
 
5585 
  def recv_getStatusDistributionOfOrders(self, ):
5586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5587 
    if mtype == TMessageType.EXCEPTION:
5588 
      x = TApplicationException()
5589 
      x.read(self._iprot)
5590 
      self._iprot.readMessageEnd()
5591 
      raise x
5592 
    result = getStatusDistributionOfOrders_result()
5593 
    result.read(self._iprot)
5594 
    self._iprot.readMessageEnd()
5595 
    if result.success is not None:
5596 
      return result.success
5597 
    if result.ex is not None:
5598 
      raise result.ex
5599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5600 
 
5067 varun.gupt 5601 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5602 
    """
5603 
    Parameters:
5604 
     - status
5605 
     - startDatetime
5606 
     - endDatetime
5607 
    """
5608 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5609 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5610 
 
5067 varun.gupt 5611 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5612 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5613 
    args = getOrderIdsForStatus_args()
5614 
    args.status = status
5615 
    args.startDatetime = startDatetime
5616 
    args.endDatetime = endDatetime
5617 
    args.write(self._oprot)
5618 
    self._oprot.writeMessageEnd()
5619 
    self._oprot.trans.flush()
5620 
 
5621 
  def recv_getOrderIdsForStatus(self, ):
5622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5623 
    if mtype == TMessageType.EXCEPTION:
5624 
      x = TApplicationException()
5625 
      x.read(self._iprot)
5626 
      self._iprot.readMessageEnd()
5627 
      raise x
5628 
    result = getOrderIdsForStatus_result()
5629 
    result.read(self._iprot)
5630 
    self._iprot.readMessageEnd()
5631 
    if result.success is not None:
5632 
      return result.success
5633 
    if result.ex is not None:
5634 
      raise result.ex
5635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5636 
 
5348 anupam.sin 5637 
  def updateCODAgent(self, agent, orderId):
5638 
    """
5639 
    Updates the agent who handled the COD verification call
5640 
 
5641 
    Parameters:
5642 
     - agent
5643 
     - orderId
5644 
    """
5645 
    self.send_updateCODAgent(agent, orderId)
5646 
    self.recv_updateCODAgent()
5647 
 
5648 
  def send_updateCODAgent(self, agent, orderId):
5649 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5650 
    args = updateCODAgent_args()
5651 
    args.agent = agent
5652 
    args.orderId = orderId
5653 
    args.write(self._oprot)
5654 
    self._oprot.writeMessageEnd()
5655 
    self._oprot.trans.flush()
5656 
 
5657 
  def recv_updateCODAgent(self, ):
5658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5659 
    if mtype == TMessageType.EXCEPTION:
5660 
      x = TApplicationException()
5661 
      x.read(self._iprot)
5662 
      self._iprot.readMessageEnd()
5663 
      raise x
5664 
    result = updateCODAgent_result()
5665 
    result.read(self._iprot)
5666 
    self._iprot.readMessageEnd()
5667 
    if result.ex is not None:
5668 
      raise result.ex
5669 
    return
5670 
 
5099 varun.gupt 5671 
  def updateOrderAsPaidToVendor(self, orderId):
5672 
    """
5673 
    Parameters:
5674 
     - orderId
5675 
    """
5676 
    self.send_updateOrderAsPaidToVendor(orderId)
5677 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5678 
 
5099 varun.gupt 5679 
  def send_updateOrderAsPaidToVendor(self, orderId):
5680 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5681 
    args = updateOrderAsPaidToVendor_args()
5682 
    args.orderId = orderId
5683 
    args.write(self._oprot)
5684 
    self._oprot.writeMessageEnd()
5685 
    self._oprot.trans.flush()
5686 
 
5687 
  def recv_updateOrderAsPaidToVendor(self, ):
5688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5689 
    if mtype == TMessageType.EXCEPTION:
5690 
      x = TApplicationException()
5691 
      x.read(self._iprot)
5692 
      self._iprot.readMessageEnd()
5693 
      raise x
5694 
    result = updateOrderAsPaidToVendor_result()
5695 
    result.read(self._iprot)
5696 
    self._iprot.readMessageEnd()
5697 
    if result.ex is not None:
5698 
      raise result.ex
5699 
    return
5700 
 
5386 phani.kuma 5701 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5702 
    """
5703 
    Parameters:
5704 
     - orderId
5705 
    """
5706 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5707 
    self.recv_updateOrderOnlyAsPaidToVendor()
5708 
 
5709 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5710 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5711 
    args = updateOrderOnlyAsPaidToVendor_args()
5712 
    args.orderId = orderId
5713 
    args.write(self._oprot)
5714 
    self._oprot.writeMessageEnd()
5715 
    self._oprot.trans.flush()
5716 
 
5717 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5719 
    if mtype == TMessageType.EXCEPTION:
5720 
      x = TApplicationException()
5721 
      x.read(self._iprot)
5722 
      self._iprot.readMessageEnd()
5723 
      raise x
5724 
    result = updateOrderOnlyAsPaidToVendor_result()
5725 
    result.read(self._iprot)
5726 
    self._iprot.readMessageEnd()
5727 
    if result.ex is not None:
5728 
      raise result.ex
5729 
    return
5730 
 
5208 varun.gupt 5731 
  def getRefundedOrdersMarkedPaid(self, ):
5732 
    self.send_getRefundedOrdersMarkedPaid()
5733 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5734 
 
5208 varun.gupt 5735 
  def send_getRefundedOrdersMarkedPaid(self, ):
5736 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5737 
    args = getRefundedOrdersMarkedPaid_args()
5738 
    args.write(self._oprot)
5739 
    self._oprot.writeMessageEnd()
5740 
    self._oprot.trans.flush()
5741 
 
5742 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5744 
    if mtype == TMessageType.EXCEPTION:
5745 
      x = TApplicationException()
5746 
      x.read(self._iprot)
5747 
      self._iprot.readMessageEnd()
5748 
      raise x
5749 
    result = getRefundedOrdersMarkedPaid_result()
5750 
    result.read(self._iprot)
5751 
    self._iprot.readMessageEnd()
5752 
    if result.success is not None:
5753 
      return result.success
5754 
    if result.ex is not None:
5755 
      raise result.ex
5756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5757 
 
5447 anupam.sin 5758 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5759 
    """
5760 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5761 
 
5447 anupam.sin 5762 
 
5763 
    Parameters:
5764 
     - minOrderId
5765 
     - maxOrderId
5766 
    """
5767 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5768 
    return self.recv_getAllVerificationAgents()
5769 
 
5770 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5771 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5772 
    args = getAllVerificationAgents_args()
5773 
    args.minOrderId = minOrderId
5774 
    args.maxOrderId = maxOrderId
5775 
    args.write(self._oprot)
5776 
    self._oprot.writeMessageEnd()
5777 
    self._oprot.trans.flush()
5778 
 
5779 
  def recv_getAllVerificationAgents(self, ):
5780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5781 
    if mtype == TMessageType.EXCEPTION:
5782 
      x = TApplicationException()
5783 
      x.read(self._iprot)
5784 
      self._iprot.readMessageEnd()
5785 
      raise x
5786 
    result = getAllVerificationAgents_result()
5787 
    result.read(self._iprot)
5788 
    self._iprot.readMessageEnd()
5789 
    if result.success is not None:
5790 
      return result.success
5791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5792 
 
5527 anupam.sin 5793 
  def getAllAttributesForOrderId(self, orderId):
5794 
    """
5795 
    gets all attributes for a given orderId
5447 anupam.sin 5796 
 
5527 anupam.sin 5797 
    Parameters:
5798 
     - orderId
5799 
    """
5800 
    self.send_getAllAttributesForOrderId(orderId)
5801 
    return self.recv_getAllAttributesForOrderId()
5802 
 
5803 
  def send_getAllAttributesForOrderId(self, orderId):
5804 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5805 
    args = getAllAttributesForOrderId_args()
5806 
    args.orderId = orderId
5807 
    args.write(self._oprot)
5808 
    self._oprot.writeMessageEnd()
5809 
    self._oprot.trans.flush()
5810 
 
5811 
  def recv_getAllAttributesForOrderId(self, ):
5812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5813 
    if mtype == TMessageType.EXCEPTION:
5814 
      x = TApplicationException()
5815 
      x.read(self._iprot)
5816 
      self._iprot.readMessageEnd()
5817 
      raise x
5818 
    result = getAllAttributesForOrderId_result()
5819 
    result.read(self._iprot)
5820 
    self._iprot.readMessageEnd()
5821 
    if result.success is not None:
5822 
      return result.success
5823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5824 
 
5676 rajveer 5825 
  def setOrderAttributes(self, orderId, attributes):
5826 
    """
5827 
    sets attributes for an order
5828 
 
5829 
    Parameters:
5830 
     - orderId
5831 
     - attributes
5832 
    """
5833 
    self.send_setOrderAttributes(orderId, attributes)
5834 
    self.recv_setOrderAttributes()
5835 
 
5836 
  def send_setOrderAttributes(self, orderId, attributes):
5837 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5838 
    args = setOrderAttributes_args()
5839 
    args.orderId = orderId
5840 
    args.attributes = attributes
5841 
    args.write(self._oprot)
5842 
    self._oprot.writeMessageEnd()
5843 
    self._oprot.trans.flush()
5844 
 
5845 
  def recv_setOrderAttributes(self, ):
5846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5847 
    if mtype == TMessageType.EXCEPTION:
5848 
      x = TApplicationException()
5849 
      x.read(self._iprot)
5850 
      self._iprot.readMessageEnd()
5851 
      raise x
5852 
    result = setOrderAttributes_result()
5853 
    result.read(self._iprot)
5854 
    self._iprot.readMessageEnd()
5855 
    return
5856 
 
5527 anupam.sin 5857 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5858 
    """
5859 
    sets attributes for all orders in a transaction
5860 
 
5861 
    Parameters:
5862 
     - transactionId
5863 
     - attribute
5864 
    """
5865 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5866 
    self.recv_setOrderAttributeForTransaction()
5867 
 
5868 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5869 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5870 
    args = setOrderAttributeForTransaction_args()
5871 
    args.transactionId = transactionId
5872 
    args.attribute = attribute
5873 
    args.write(self._oprot)
5874 
    self._oprot.writeMessageEnd()
5875 
    self._oprot.trans.flush()
5876 
 
5877 
  def recv_setOrderAttributeForTransaction(self, ):
5878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5879 
    if mtype == TMessageType.EXCEPTION:
5880 
      x = TApplicationException()
5881 
      x.read(self._iprot)
5882 
      self._iprot.readMessageEnd()
5883 
      raise x
5884 
    result = setOrderAttributeForTransaction_result()
5885 
    result.read(self._iprot)
5886 
    self._iprot.readMessageEnd()
5887 
    return
5888 
 
5553 rajveer 5889 
  def getReceivePendingOrders(self, storeId):
5890 
    """
5891 
    Parameters:
5892 
     - storeId
5893 
    """
5894 
    self.send_getReceivePendingOrders(storeId)
5895 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5896 
 
5553 rajveer 5897 
  def send_getReceivePendingOrders(self, storeId):
5898 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5899 
    args = getReceivePendingOrders_args()
5900 
    args.storeId = storeId
5901 
    args.write(self._oprot)
5902 
    self._oprot.writeMessageEnd()
5903 
    self._oprot.trans.flush()
5904 
 
5905 
  def recv_getReceivePendingOrders(self, ):
5906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5907 
    if mtype == TMessageType.EXCEPTION:
5908 
      x = TApplicationException()
5909 
      x.read(self._iprot)
5910 
      self._iprot.readMessageEnd()
5911 
      raise x
5912 
    result = getReceivePendingOrders_result()
5913 
    result.read(self._iprot)
5914 
    self._iprot.readMessageEnd()
5915 
    if result.success is not None:
5916 
      return result.success
5917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5918 
 
5919 
  def getReceivedAtStoreOrders(self, storeId):
5920 
    """
5921 
    Parameters:
5922 
     - storeId
5923 
    """
5924 
    self.send_getReceivedAtStoreOrders(storeId)
5925 
    return self.recv_getReceivedAtStoreOrders()
5926 
 
5927 
  def send_getReceivedAtStoreOrders(self, storeId):
5928 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5929 
    args = getReceivedAtStoreOrders_args()
5930 
    args.storeId = storeId
5931 
    args.write(self._oprot)
5932 
    self._oprot.writeMessageEnd()
5933 
    self._oprot.trans.flush()
5934 
 
5935 
  def recv_getReceivedAtStoreOrders(self, ):
5936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5937 
    if mtype == TMessageType.EXCEPTION:
5938 
      x = TApplicationException()
5939 
      x.read(self._iprot)
5940 
      self._iprot.readMessageEnd()
5941 
      raise x
5942 
    result = getReceivedAtStoreOrders_result()
5943 
    result.read(self._iprot)
5944 
    self._iprot.readMessageEnd()
5945 
    if result.success is not None:
5946 
      return result.success
5947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5948 
 
5713 rajveer 5949 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5950 
    """
5951 
    Parameters:
5952 
     - storeId
5953 
     - fromDate
5954 
     - toDate
5955 
     - onlyCod
5956 
    """
5957 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5958 
    return self.recv_getOrdersCollectionAtStore()
5959 
 
5960 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5961 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5962 
    args = getOrdersCollectionAtStore_args()
5963 
    args.storeId = storeId
5964 
    args.fromDate = fromDate
5965 
    args.toDate = toDate
5966 
    args.onlyCod = onlyCod
5967 
    args.write(self._oprot)
5968 
    self._oprot.writeMessageEnd()
5969 
    self._oprot.trans.flush()
5970 
 
5971 
  def recv_getOrdersCollectionAtStore(self, ):
5972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5973 
    if mtype == TMessageType.EXCEPTION:
5974 
      x = TApplicationException()
5975 
      x.read(self._iprot)
5976 
      self._iprot.readMessageEnd()
5977 
      raise x
5978 
    result = getOrdersCollectionAtStore_result()
5979 
    result.read(self._iprot)
5980 
    self._iprot.readMessageEnd()
5981 
    if result.success is not None:
5982 
      return result.success
5983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5984 
 
5833 rajveer 5985 
  def getOrderAttributeValue(self, orderId, attributeName):
5986 
    """
5987 
    Parameters:
5988 
     - orderId
5989 
     - attributeName
5990 
    """
5991 
    self.send_getOrderAttributeValue(orderId, attributeName)
5992 
    return self.recv_getOrderAttributeValue()
5993 
 
5994 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5995 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5996 
    args = getOrderAttributeValue_args()
5997 
    args.orderId = orderId
5998 
    args.attributeName = attributeName
5999 
    args.write(self._oprot)
6000 
    self._oprot.writeMessageEnd()
6001 
    self._oprot.trans.flush()
6002 
 
6003 
  def recv_getOrderAttributeValue(self, ):
6004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6005 
    if mtype == TMessageType.EXCEPTION:
6006 
      x = TApplicationException()
6007 
      x.read(self._iprot)
6008 
      self._iprot.readMessageEnd()
6009 
      raise x
6010 
    result = getOrderAttributeValue_result()
6011 
    result.read(self._iprot)
6012 
    self._iprot.readMessageEnd()
6013 
    if result.success is not None:
6014 
      return result.success
6015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
6016 
 
6019 rajveer 6017 
  def changeJacketNumber(self, orderId, jacketNumber):
6018 
    """
6019 
    Parameters:
6020 
     - orderId
6021 
     - jacketNumber
6022 
    """
6023 
    self.send_changeJacketNumber(orderId, jacketNumber)
6024 
    return self.recv_changeJacketNumber()
6025 
 
6026 
  def send_changeJacketNumber(self, orderId, jacketNumber):
6027 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
6028 
    args = changeJacketNumber_args()
6029 
    args.orderId = orderId
6030 
    args.jacketNumber = jacketNumber
6031 
    args.write(self._oprot)
6032 
    self._oprot.writeMessageEnd()
6033 
    self._oprot.trans.flush()
6034 
 
6035 
  def recv_changeJacketNumber(self, ):
6036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6037 
    if mtype == TMessageType.EXCEPTION:
6038 
      x = TApplicationException()
6039 
      x.read(self._iprot)
6040 
      self._iprot.readMessageEnd()
6041 
      raise x
6042 
    result = changeJacketNumber_result()
6043 
    result.read(self._iprot)
6044 
    self._iprot.readMessageEnd()
6045 
    if result.success is not None:
6046 
      return result.success
6047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
6048 
 
6049 
  def markOrderAsRtoInTransit(self, orderId):
6050 
    """
6051 
    Parameters:
6052 
     - orderId
6053 
    """
6054 
    self.send_markOrderAsRtoInTransit(orderId)
6055 
    return self.recv_markOrderAsRtoInTransit()
6056 
 
6057 
  def send_markOrderAsRtoInTransit(self, orderId):
6058 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
6059 
    args = markOrderAsRtoInTransit_args()
6060 
    args.orderId = orderId
6061 
    args.write(self._oprot)
6062 
    self._oprot.writeMessageEnd()
6063 
    self._oprot.trans.flush()
6064 
 
6065 
  def recv_markOrderAsRtoInTransit(self, ):
6066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6067 
    if mtype == TMessageType.EXCEPTION:
6068 
      x = TApplicationException()
6069 
      x.read(self._iprot)
6070 
      self._iprot.readMessageEnd()
6071 
      raise x
6072 
    result = markOrderAsRtoInTransit_result()
6073 
    result.read(self._iprot)
6074 
    self._iprot.readMessageEnd()
6075 
    if result.success is not None:
6076 
      return result.success
6077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
6078 
 
5593 mandeep.dh 6079 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6080 
    """
6081 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
6082 
    invoked while scanning IN of items.
5553 rajveer 6083 
 
5593 mandeep.dh 6084 
    Parameters:
6085 
     - itemId
6086 
     - quantity
6087 
     - fulfilmentWarehouseId
6088 
     - billingWarehouseId
6089 
    """
6090 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
6091 
    self.recv_acceptOrderForItem()
6092 
 
6093 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6094 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
6095 
    args = acceptOrderForItem_args()
6096 
    args.itemId = itemId
6097 
    args.quantity = quantity
6098 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
6099 
    args.billingWarehouseId = billingWarehouseId
6100 
    args.write(self._oprot)
6101 
    self._oprot.writeMessageEnd()
6102 
    self._oprot.trans.flush()
6103 
 
6104 
  def recv_acceptOrderForItem(self, ):
6105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6106 
    if mtype == TMessageType.EXCEPTION:
6107 
      x = TApplicationException()
6108 
      x.read(self._iprot)
6109 
      self._iprot.readMessageEnd()
6110 
      raise x
6111 
    result = acceptOrderForItem_result()
6112 
    result.read(self._iprot)
6113 
    self._iprot.readMessageEnd()
6114 
    return
6115 
 
6000 mandeep.dh 6116 
  def createRechargeOrder(self, rechargeOrder):
6117 
    """
6118 
    Parameters:
6119 
     - rechargeOrder
6120 
    """
6121 
    self.send_createRechargeOrder(rechargeOrder)
6122 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6123 
 
6000 mandeep.dh 6124 
  def send_createRechargeOrder(self, rechargeOrder):
6125 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6126 
    args = createRechargeOrder_args()
6127 
    args.rechargeOrder = rechargeOrder
6128 
    args.write(self._oprot)
6129 
    self._oprot.writeMessageEnd()
6130 
    self._oprot.trans.flush()
6131 
 
6132 
  def recv_createRechargeOrder(self, ):
6133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6134 
    if mtype == TMessageType.EXCEPTION:
6135 
      x = TApplicationException()
6136 
      x.read(self._iprot)
6137 
      self._iprot.readMessageEnd()
6138 
      raise x
6139 
    result = createRechargeOrder_result()
6140 
    result.read(self._iprot)
6141 
    self._iprot.readMessageEnd()
6142 
    if result.success is not None:
6143 
      return result.success
6144 
    if result.ex is not None:
6145 
      raise result.ex
6146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6147 
 
6031 rajveer 6148 
  def getRechargeOrder(self, rechargeRrderId):
6149 
    """
6150 
    Parameters:
6151 
     - rechargeRrderId
6152 
    """
6153 
    self.send_getRechargeOrder(rechargeRrderId)
6154 
    return self.recv_getRechargeOrder()
6155 
 
6156 
  def send_getRechargeOrder(self, rechargeRrderId):
6157 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6158 
    args = getRechargeOrder_args()
6159 
    args.rechargeRrderId = rechargeRrderId
6160 
    args.write(self._oprot)
6161 
    self._oprot.writeMessageEnd()
6162 
    self._oprot.trans.flush()
6163 
 
6164 
  def recv_getRechargeOrder(self, ):
6165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6166 
    if mtype == TMessageType.EXCEPTION:
6167 
      x = TApplicationException()
6168 
      x.read(self._iprot)
6169 
      self._iprot.readMessageEnd()
6170 
      raise x
6171 
    result = getRechargeOrder_result()
6172 
    result.read(self._iprot)
6173 
    self._iprot.readMessageEnd()
6174 
    if result.success is not None:
6175 
      return result.success
6176 
    if result.ex is not None:
6177 
      raise result.ex
6178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6179 
 
6180 
  def getRechargeOrders(self, userId):
6181 
    """
6182 
    Parameters:
6183 
     - userId
6184 
    """
6185 
    self.send_getRechargeOrders(userId)
6186 
    return self.recv_getRechargeOrders()
6187 
 
6188 
  def send_getRechargeOrders(self, userId):
6189 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6190 
    args = getRechargeOrders_args()
6191 
    args.userId = userId
6192 
    args.write(self._oprot)
6193 
    self._oprot.writeMessageEnd()
6194 
    self._oprot.trans.flush()
6195 
 
6196 
  def recv_getRechargeOrders(self, ):
6197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6198 
    if mtype == TMessageType.EXCEPTION:
6199 
      x = TApplicationException()
6200 
      x.read(self._iprot)
6201 
      self._iprot.readMessageEnd()
6202 
      raise x
6203 
    result = getRechargeOrders_result()
6204 
    result.read(self._iprot)
6205 
    self._iprot.readMessageEnd()
6206 
    if result.success is not None:
6207 
      return result.success
6208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6209 
 
6000 mandeep.dh 6210 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6211 
    """
6212 
    Parameters:
6213 
     - rechargeOrderId
6214 
     - rechargeOrderStatus
6215 
    """
6216 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6217 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6218 
 
6219 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6220 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6221 
    args = updateRechargeOrderStatus_args()
6222 
    args.rechargeOrderId = rechargeOrderId
6223 
    args.rechargeOrderStatus = rechargeOrderStatus
6224 
    args.write(self._oprot)
6225 
    self._oprot.writeMessageEnd()
6226 
    self._oprot.trans.flush()
6227 
 
6228 
  def recv_updateRechargeOrderStatus(self, ):
6229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6230 
    if mtype == TMessageType.EXCEPTION:
6231 
      x = TApplicationException()
6232 
      x.read(self._iprot)
6233 
      self._iprot.readMessageEnd()
6234 
      raise x
6235 
    result = updateRechargeOrderStatus_result()
6236 
    result.read(self._iprot)
6237 
    self._iprot.readMessageEnd()
6031 rajveer 6238 
    if result.success is not None:
6239 
      return result.success
6000 mandeep.dh 6240 
    if result.ex is not None:
6241 
      raise result.ex
6031 rajveer 6242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6243 
 
6031 rajveer 6244 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6245 
    """
6246 
    Parameters:
6031 rajveer 6247 
     - rechargeOrderId
6000 mandeep.dh 6248 
    """
6031 rajveer 6249 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6250 
    return self.recv_activateRechargeTxn()
6251 
 
6031 rajveer 6252 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6253 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6254 
    args = activateRechargeTxn_args()
6031 rajveer 6255 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6256 
    args.write(self._oprot)
6257 
    self._oprot.writeMessageEnd()
6258 
    self._oprot.trans.flush()
6259 
 
6260 
  def recv_activateRechargeTxn(self, ):
6261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6262 
    if mtype == TMessageType.EXCEPTION:
6263 
      x = TApplicationException()
6264 
      x.read(self._iprot)
6265 
      self._iprot.readMessageEnd()
6266 
      raise x
6267 
    result = activateRechargeTxn_result()
6268 
    result.read(self._iprot)
6269 
    self._iprot.readMessageEnd()
6270 
    if result.success is not None:
6271 
      return result.success
6272 
    if result.ex is not None:
6273 
      raise result.ex
6274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6275 
 
6031 rajveer 6276 
  def getUserWallet(self, userId):
6000 mandeep.dh 6277 
    """
6278 
    Parameters:
6031 rajveer 6279 
     - userId
6000 mandeep.dh 6280 
    """
6031 rajveer 6281 
    self.send_getUserWallet(userId)
6282 
    return self.recv_getUserWallet()
6000 mandeep.dh 6283 
 
6031 rajveer 6284 
  def send_getUserWallet(self, userId):
6285 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6286 
    args = getUserWallet_args()
6287 
    args.userId = userId
6000 mandeep.dh 6288 
    args.write(self._oprot)
6289 
    self._oprot.writeMessageEnd()
6290 
    self._oprot.trans.flush()
6291 
 
6031 rajveer 6292 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6294 
    if mtype == TMessageType.EXCEPTION:
6295 
      x = TApplicationException()
6296 
      x.read(self._iprot)
6297 
      self._iprot.readMessageEnd()
6298 
      raise x
6031 rajveer 6299 
    result = getUserWallet_result()
6000 mandeep.dh 6300 
    result.read(self._iprot)
6301 
    self._iprot.readMessageEnd()
6302 
    if result.success is not None:
6303 
      return result.success
6031 rajveer 6304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6305 
 
6031 rajveer 6306 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6307 
    """
6308 
    Parameters:
6031 rajveer 6309 
     - userId
6000 mandeep.dh 6310 
    """
6031 rajveer 6311 
    self.send_getUserWalletHistory(userId)
6312 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6313 
 
6031 rajveer 6314 
  def send_getUserWalletHistory(self, userId):
6315 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6316 
    args = getUserWalletHistory_args()
6317 
    args.userId = userId
6000 mandeep.dh 6318 
    args.write(self._oprot)
6319 
    self._oprot.writeMessageEnd()
6320 
    self._oprot.trans.flush()
6321 
 
6031 rajveer 6322 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6324 
    if mtype == TMessageType.EXCEPTION:
6325 
      x = TApplicationException()
6326 
      x.read(self._iprot)
6327 
      self._iprot.readMessageEnd()
6328 
      raise x
6031 rajveer 6329 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6330 
    result.read(self._iprot)
6331 
    self._iprot.readMessageEnd()
6332 
    if result.success is not None:
6333 
      return result.success
6031 rajveer 6334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6335 
 
6050 anupam.sin 6336 
  def getRechargeOrdersForTransaction(self, txnId):
6337 
    """
6338 
    Returns a recharge order for a given transactionId
6339 
 
6340 
    Parameters:
6341 
     - txnId
6342 
    """
6343 
    self.send_getRechargeOrdersForTransaction(txnId)
6344 
    return self.recv_getRechargeOrdersForTransaction()
6345 
 
6346 
  def send_getRechargeOrdersForTransaction(self, txnId):
6347 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6348 
    args = getRechargeOrdersForTransaction_args()
6349 
    args.txnId = txnId
6350 
    args.write(self._oprot)
6351 
    self._oprot.writeMessageEnd()
6352 
    self._oprot.trans.flush()
6353 
 
6354 
  def recv_getRechargeOrdersForTransaction(self, ):
6355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6356 
    if mtype == TMessageType.EXCEPTION:
6357 
      x = TApplicationException()
6358 
      x.read(self._iprot)
6359 
      self._iprot.readMessageEnd()
6360 
      raise x
6361 
    result = getRechargeOrdersForTransaction_result()
6362 
    result.read(self._iprot)
6363 
    self._iprot.readMessageEnd()
6364 
    if result.success is not None:
6365 
      return result.success
6366 
    if result.ex is not None:
6367 
      raise result.ex
6368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6369 
 
6206 rajveer 6370 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6371 
    """
6372 
    Parameters:
6373 
     - rechargeType
6206 rajveer 6374 
     - onlyActive
6048 rajveer 6375 
    """
6206 rajveer 6376 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6377 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6378 
 
6206 rajveer 6379 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6380 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6381 
    args = getServiceProviders_args()
6382 
    args.rechargeType = rechargeType
6206 rajveer 6383 
    args.onlyActive = onlyActive
6048 rajveer 6384 
    args.write(self._oprot)
6385 
    self._oprot.writeMessageEnd()
6386 
    self._oprot.trans.flush()
6387 
 
6388 
  def recv_getServiceProviders(self, ):
6389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6390 
    if mtype == TMessageType.EXCEPTION:
6391 
      x = TApplicationException()
6392 
      x.read(self._iprot)
6393 
      self._iprot.readMessageEnd()
6394 
      raise x
6395 
    result = getServiceProviders_result()
6396 
    result.read(self._iprot)
6397 
    self._iprot.readMessageEnd()
6398 
    if result.success is not None:
6399 
      return result.success
6400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6401 
 
6049 rajveer 6402 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6403 
    """
6404 
    Parameters:
6049 rajveer 6405 
     - rechargeType
6048 rajveer 6406 
     - deviceNumber
6407 
    """
6049 rajveer 6408 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6409 
    return self.recv_getServiceProviderForDevice()
6410 
 
6049 rajveer 6411 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6412 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6413 
    args = getServiceProviderForDevice_args()
6049 rajveer 6414 
    args.rechargeType = rechargeType
6048 rajveer 6415 
    args.deviceNumber = deviceNumber
6416 
    args.write(self._oprot)
6417 
    self._oprot.writeMessageEnd()
6418 
    self._oprot.trans.flush()
6419 
 
6420 
  def recv_getServiceProviderForDevice(self, ):
6421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6422 
    if mtype == TMessageType.EXCEPTION:
6423 
      x = TApplicationException()
6424 
      x.read(self._iprot)
6425 
      self._iprot.readMessageEnd()
6426 
      raise x
6427 
    result = getServiceProviderForDevice_result()
6428 
    result.read(self._iprot)
6429 
    self._iprot.readMessageEnd()
6430 
    if result.success is not None:
6431 
      return result.success
6432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6433 
 
6591 anupam.sin 6434 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6435 
    """
6436 
    Parameters:
6437 
     - rechargeType
6438 
     - deviceNumber
6307 anupam.sin 6439 
     - userSelectedProviderId
6591 anupam.sin 6440 
     - clientAddress
6269 rajveer 6441 
    """
6591 anupam.sin 6442 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6443 
    return self.recv_validateRecharge()
6444 
 
6591 anupam.sin 6445 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6446 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6447 
    args = validateRecharge_args()
6448 
    args.rechargeType = rechargeType
6449 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6450 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6451 
    args.clientAddress = clientAddress
6269 rajveer 6452 
    args.write(self._oprot)
6453 
    self._oprot.writeMessageEnd()
6454 
    self._oprot.trans.flush()
6455 
 
6456 
  def recv_validateRecharge(self, ):
6457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6458 
    if mtype == TMessageType.EXCEPTION:
6459 
      x = TApplicationException()
6460 
      x.read(self._iprot)
6461 
      self._iprot.readMessageEnd()
6462 
      raise x
6463 
    result = validateRecharge_result()
6464 
    result.read(self._iprot)
6465 
    self._iprot.readMessageEnd()
6466 
    if result.success is not None:
6467 
      return result.success
6468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6469 
 
6094 rajveer 6470 
  def getRechargeOrdersForDevice(self, deviceNumber):
6471 
    """
6472 
    Parameters:
6473 
     - deviceNumber
6474 
    """
6475 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6476 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6477 
 
6094 rajveer 6478 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6479 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6480 
    args = getRechargeOrdersForDevice_args()
6481 
    args.deviceNumber = deviceNumber
6482 
    args.write(self._oprot)
6483 
    self._oprot.writeMessageEnd()
6484 
    self._oprot.trans.flush()
6485 
 
6486 
  def recv_getRechargeOrdersForDevice(self, ):
6487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6488 
    if mtype == TMessageType.EXCEPTION:
6489 
      x = TApplicationException()
6490 
      x.read(self._iprot)
6491 
      self._iprot.readMessageEnd()
6492 
      raise x
6493 
    result = getRechargeOrdersForDevice_result()
6494 
    result.read(self._iprot)
6495 
    self._iprot.readMessageEnd()
6496 
    if result.success is not None:
6497 
      return result.success
6498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6499 
 
6500 
  def addAmountToWallet(self, userId, orderId, amount):
6501 
    """
6502 
    Parameters:
6503 
     - userId
6504 
     - orderId
6505 
     - amount
6506 
    """
6507 
    self.send_addAmountToWallet(userId, orderId, amount)
6508 
    self.recv_addAmountToWallet()
6509 
 
6510 
  def send_addAmountToWallet(self, userId, orderId, amount):
6511 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6512 
    args = addAmountToWallet_args()
6513 
    args.userId = userId
6514 
    args.orderId = orderId
6515 
    args.amount = amount
6516 
    args.write(self._oprot)
6517 
    self._oprot.writeMessageEnd()
6518 
    self._oprot.trans.flush()
6519 
 
6520 
  def recv_addAmountToWallet(self, ):
6521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6522 
    if mtype == TMessageType.EXCEPTION:
6523 
      x = TApplicationException()
6524 
      x.read(self._iprot)
6525 
      self._iprot.readMessageEnd()
6526 
      raise x
6527 
    result = addAmountToWallet_result()
6528 
    result.read(self._iprot)
6529 
    self._iprot.readMessageEnd()
6530 
    return
6531 
 
6188 rajveer 6532 
  def getRechargeStatistics(self, ):
6533 
    self.send_getRechargeStatistics()
6534 
    return self.recv_getRechargeStatistics()
6535 
 
6536 
  def send_getRechargeStatistics(self, ):
6537 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6538 
    args = getRechargeStatistics_args()
6539 
    args.write(self._oprot)
6540 
    self._oprot.writeMessageEnd()
6541 
    self._oprot.trans.flush()
6542 
 
6543 
  def recv_getRechargeStatistics(self, ):
6544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6545 
    if mtype == TMessageType.EXCEPTION:
6546 
      x = TApplicationException()
6547 
      x.read(self._iprot)
6548 
      self._iprot.readMessageEnd()
6549 
      raise x
6550 
    result = getRechargeStatistics_result()
6551 
    result.read(self._iprot)
6552 
    self._iprot.readMessageEnd()
6553 
    if result.success is not None:
6554 
      return result.success
6555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6556 
 
6154 rajveer 6557 
  def getRechargeOrdersForStatus(self, status):
6558 
    """
6559 
    Parameters:
6560 
     - status
6561 
    """
6562 
    self.send_getRechargeOrdersForStatus(status)
6563 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6564 
 
6154 rajveer 6565 
  def send_getRechargeOrdersForStatus(self, status):
6566 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6567 
    args = getRechargeOrdersForStatus_args()
6568 
    args.status = status
6569 
    args.write(self._oprot)
6570 
    self._oprot.writeMessageEnd()
6571 
    self._oprot.trans.flush()
6572 
 
6573 
  def recv_getRechargeOrdersForStatus(self, ):
6574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6575 
    if mtype == TMessageType.EXCEPTION:
6576 
      x = TApplicationException()
6577 
      x.read(self._iprot)
6578 
      self._iprot.readMessageEnd()
6579 
      raise x
6580 
    result = getRechargeOrdersForStatus_result()
6581 
    result.read(self._iprot)
6582 
    self._iprot.readMessageEnd()
6583 
    if result.success is not None:
6584 
      return result.success
6585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6586 
 
6159 rajveer 6587 
  def getPlansForOperator(self, operatorId):
6588 
    """
6589 
    Parameters:
6590 
     - operatorId
6591 
    """
6592 
    self.send_getPlansForOperator(operatorId)
6593 
    return self.recv_getPlansForOperator()
6154 rajveer 6594 
 
6159 rajveer 6595 
  def send_getPlansForOperator(self, operatorId):
6596 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6597 
    args = getPlansForOperator_args()
6598 
    args.operatorId = operatorId
6599 
    args.write(self._oprot)
6600 
    self._oprot.writeMessageEnd()
6601 
    self._oprot.trans.flush()
6602 
 
6603 
  def recv_getPlansForOperator(self, ):
6604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6605 
    if mtype == TMessageType.EXCEPTION:
6606 
      x = TApplicationException()
6607 
      x.read(self._iprot)
6608 
      self._iprot.readMessageEnd()
6609 
      raise x
6610 
    result = getPlansForOperator_result()
6611 
    result.read(self._iprot)
6612 
    self._iprot.readMessageEnd()
6613 
    if result.success is not None:
6614 
      return result.success
6615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6616 
 
6307 anupam.sin 6617 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6618 
    """
6619 
    Returns denominations for a given operator and circle
6159 rajveer 6620 
 
6289 anupam.sin 6621 
    Parameters:
6622 
     - operatorId
6307 anupam.sin 6623 
     - circleCode
6289 anupam.sin 6624 
     - denominationType
6625 
    """
6307 anupam.sin 6626 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6627 
    return self.recv_getRechargeDenominations()
6628 
 
6307 anupam.sin 6629 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6630 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6631 
    args = getRechargeDenominations_args()
6632 
    args.operatorId = operatorId
6307 anupam.sin 6633 
    args.circleCode = circleCode
6289 anupam.sin 6634 
    args.denominationType = denominationType
6635 
    args.write(self._oprot)
6636 
    self._oprot.writeMessageEnd()
6637 
    self._oprot.trans.flush()
6638 
 
6639 
  def recv_getRechargeDenominations(self, ):
6640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6641 
    if mtype == TMessageType.EXCEPTION:
6642 
      x = TApplicationException()
6643 
      x.read(self._iprot)
6644 
      self._iprot.readMessageEnd()
6645 
      raise x
6646 
    result = getRechargeDenominations_result()
6647 
    result.read(self._iprot)
6648 
    self._iprot.readMessageEnd()
6649 
    if result.success is not None:
6650 
      return result.success
6651 
    if result.ex is not None:
6652 
      raise result.ex
6653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6654 
 
6371 rajveer 6655 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6656 
    """
6657 
    Parameters:
6658 
     - operatorId
6659 
     - circleId
6660 
     - isAvailable
6661 
    """
6662 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6663 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6664 
 
6371 rajveer 6665 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6666 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6667 
    args = updateAvailabilityStatus_args()
6668 
    args.operatorId = operatorId
6669 
    args.circleId = circleId
6670 
    args.isAvailable = isAvailable
6671 
    args.write(self._oprot)
6672 
    self._oprot.writeMessageEnd()
6673 
    self._oprot.trans.flush()
6674 
 
6675 
  def recv_updateAvailabilityStatus(self, ):
6676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6677 
    if mtype == TMessageType.EXCEPTION:
6678 
      x = TApplicationException()
6679 
      x.read(self._iprot)
6680 
      self._iprot.readMessageEnd()
6681 
      raise x
6682 
    result = updateAvailabilityStatus_result()
6683 
    result.read(self._iprot)
6684 
    self._iprot.readMessageEnd()
6685 
    return
6686 
 
6389 rajveer 6687 
  def getAvailableEmiSchemes(self, ):
6688 
    self.send_getAvailableEmiSchemes()
6689 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6690 
 
6389 rajveer 6691 
  def send_getAvailableEmiSchemes(self, ):
6692 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6693 
    args = getAvailableEmiSchemes_args()
6694 
    args.write(self._oprot)
6695 
    self._oprot.writeMessageEnd()
6696 
    self._oprot.trans.flush()
6697 
 
6698 
  def recv_getAvailableEmiSchemes(self, ):
6699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6700 
    if mtype == TMessageType.EXCEPTION:
6701 
      x = TApplicationException()
6702 
      x.read(self._iprot)
6703 
      self._iprot.readMessageEnd()
6704 
      raise x
6705 
    result = getAvailableEmiSchemes_result()
6706 
    result.read(self._iprot)
6707 
    self._iprot.readMessageEnd()
6708 
    if result.success is not None:
6709 
      return result.success
6710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6711 
 
6712 
  def getMiscCharges(self, transactionId):
6713 
    """
6714 
    Parameters:
6715 
     - transactionId
6716 
    """
6717 
    self.send_getMiscCharges(transactionId)
6718 
    return self.recv_getMiscCharges()
6719 
 
6720 
  def send_getMiscCharges(self, transactionId):
6721 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6722 
    args = getMiscCharges_args()
6723 
    args.transactionId = transactionId
6724 
    args.write(self._oprot)
6725 
    self._oprot.writeMessageEnd()
6726 
    self._oprot.trans.flush()
6727 
 
6728 
  def recv_getMiscCharges(self, ):
6729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6730 
    if mtype == TMessageType.EXCEPTION:
6731 
      x = TApplicationException()
6732 
      x.read(self._iprot)
6733 
      self._iprot.readMessageEnd()
6734 
      raise x
6735 
    result = getMiscCharges_result()
6736 
    result.read(self._iprot)
6737 
    self._iprot.readMessageEnd()
6738 
    if result.success is not None:
6739 
      return result.success
6740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6741 
 
6507 anupam.sin 6742 
  def refundRechargeOrder(self, rechargeOrderId):
6743 
    """
6744 
    Parameters:
6745 
     - rechargeOrderId
6746 
    """
6747 
    self.send_refundRechargeOrder(rechargeOrderId)
6748 
    return self.recv_refundRechargeOrder()
6389 rajveer 6749 
 
6507 anupam.sin 6750 
  def send_refundRechargeOrder(self, rechargeOrderId):
6751 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6752 
    args = refundRechargeOrder_args()
6753 
    args.rechargeOrderId = rechargeOrderId
6754 
    args.write(self._oprot)
6755 
    self._oprot.writeMessageEnd()
6756 
    self._oprot.trans.flush()
6757 
 
6758 
  def recv_refundRechargeOrder(self, ):
6759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6760 
    if mtype == TMessageType.EXCEPTION:
6761 
      x = TApplicationException()
6762 
      x.read(self._iprot)
6763 
      self._iprot.readMessageEnd()
6764 
      raise x
6765 
    result = refundRechargeOrder_result()
6766 
    result.read(self._iprot)
6767 
    self._iprot.readMessageEnd()
6768 
    if result.success is not None:
6769 
      return result.success
6770 
    if result.ex is not None:
6771 
      raise result.ex
6772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6773 
 
6821 amar.kumar 6774 
  def getPhysicalOrders(self, fromDate, toDate):
6775 
    """
6776 
    Parameters:
6777 
     - fromDate
6778 
     - toDate
6779 
    """
6780 
    self.send_getPhysicalOrders(fromDate, toDate)
6781 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6782 
 
6821 amar.kumar 6783 
  def send_getPhysicalOrders(self, fromDate, toDate):
6784 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6785 
    args = getPhysicalOrders_args()
6786 
    args.fromDate = fromDate
6787 
    args.toDate = toDate
6788 
    args.write(self._oprot)
6789 
    self._oprot.writeMessageEnd()
6790 
    self._oprot.trans.flush()
6791 
 
6792 
  def recv_getPhysicalOrders(self, ):
6793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6794 
    if mtype == TMessageType.EXCEPTION:
6795 
      x = TApplicationException()
6796 
      x.read(self._iprot)
6797 
      self._iprot.readMessageEnd()
6798 
      raise x
6799 
    result = getPhysicalOrders_result()
6800 
    result.read(self._iprot)
6801 
    self._iprot.readMessageEnd()
6802 
    if result.success is not None:
6803 
      return result.success
6804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6805 
 
6906 rajveer 6806 
  def getDocument(self, docType, docSource):
6807 
    """
6808 
    Parameters:
6809 
     - docType
6810 
     - docSource
6811 
    """
6812 
    self.send_getDocument(docType, docSource)
6813 
    return self.recv_getDocument()
6821 amar.kumar 6814 
 
6906 rajveer 6815 
  def send_getDocument(self, docType, docSource):
6816 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6817 
    args = getDocument_args()
6818 
    args.docType = docType
6819 
    args.docSource = docSource
6820 
    args.write(self._oprot)
6821 
    self._oprot.writeMessageEnd()
6822 
    self._oprot.trans.flush()
6823 
 
6824 
  def recv_getDocument(self, ):
6825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6826 
    if mtype == TMessageType.EXCEPTION:
6827 
      x = TApplicationException()
6828 
      x.read(self._iprot)
6829 
      self._iprot.readMessageEnd()
6830 
      raise x
6831 
    result = getDocument_result()
6832 
    result.read(self._iprot)
6833 
    self._iprot.readMessageEnd()
6834 
    if result.success is not None:
6835 
      return result.success
6836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6837 
 
6985 anupam.sin 6838 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6839 
    """
6840 
    Parameters:
6841 
     - orderId
6842 
     - line1
6843 
     - line2
6844 
     - city
6845 
     - state
6846 
     - pin
6847 
    """
6848 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6849 
    return self.recv_changeShippingAddress()
6906 rajveer 6850 
 
6985 anupam.sin 6851 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6852 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6853 
    args = changeShippingAddress_args()
6854 
    args.orderId = orderId
6855 
    args.line1 = line1
6856 
    args.line2 = line2
6857 
    args.city = city
6858 
    args.state = state
6859 
    args.pin = pin
6860 
    args.write(self._oprot)
6861 
    self._oprot.writeMessageEnd()
6862 
    self._oprot.trans.flush()
6863 
 
6864 
  def recv_changeShippingAddress(self, ):
6865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6866 
    if mtype == TMessageType.EXCEPTION:
6867 
      x = TApplicationException()
6868 
      x.read(self._iprot)
6869 
      self._iprot.readMessageEnd()
6870 
      raise x
6871 
    result = changeShippingAddress_result()
6872 
    result.read(self._iprot)
6873 
    self._iprot.readMessageEnd()
6874 
    if result.success is not None:
6875 
      return result.success
6876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6877 
 
7075 rajveer 6878 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6879 
    """
6880 
    Parameters:
6881 
     - orderId
7075 rajveer 6882 
     - userId
6988 rajveer 6883 
    """
7075 rajveer 6884 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6885 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6886 
 
7075 rajveer 6887 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6888 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6889 
    args = retrieveInvoice_args()
6890 
    args.orderId = orderId
7075 rajveer 6891 
    args.userId = userId
6988 rajveer 6892 
    args.write(self._oprot)
6893 
    self._oprot.writeMessageEnd()
6894 
    self._oprot.trans.flush()
6895 
 
6896 
  def recv_retrieveInvoice(self, ):
6897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6898 
    if mtype == TMessageType.EXCEPTION:
6899 
      x = TApplicationException()
6900 
      x.read(self._iprot)
6901 
      self._iprot.readMessageEnd()
6902 
      raise x
6903 
    result = retrieveInvoice_result()
6904 
    result.read(self._iprot)
6905 
    self._iprot.readMessageEnd()
6906 
    if result.success is not None:
6907 
      return result.success
6908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6909 
 
7026 rajveer 6910 
  def receiveUpdatesForRedExpress(self, awbNumber):
6911 
    """
6912 
    Parameters:
6913 
     - awbNumber
6914 
    """
6915 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6916 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6917 
 
7026 rajveer 6918 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6919 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6920 
    args = receiveUpdatesForRedExpress_args()
6921 
    args.awbNumber = awbNumber
6922 
    args.write(self._oprot)
6923 
    self._oprot.writeMessageEnd()
6924 
    self._oprot.trans.flush()
6925 
 
6926 
  def recv_receiveUpdatesForRedExpress(self, ):
6927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6928 
    if mtype == TMessageType.EXCEPTION:
6929 
      x = TApplicationException()
6930 
      x.read(self._iprot)
6931 
      self._iprot.readMessageEnd()
6932 
      raise x
6933 
    result = receiveUpdatesForRedExpress_result()
6934 
    result.read(self._iprot)
6935 
    self._iprot.readMessageEnd()
6936 
    if result.success is not None:
6937 
      return result.success
6938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6939 
 
7073 anupam.sin 6940 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6941 
    """
6942 
    Parameters:
6943 
     - thriftRechargeTransaction
6944 
    """
6945 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6946 
    return self.recv_createRechargeTransaction()
7026 rajveer 6947 
 
7073 anupam.sin 6948 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6949 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6950 
    args = createRechargeTransaction_args()
6951 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6952 
    args.write(self._oprot)
6953 
    self._oprot.writeMessageEnd()
6954 
    self._oprot.trans.flush()
6955 
 
6956 
  def recv_createRechargeTransaction(self, ):
6957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6958 
    if mtype == TMessageType.EXCEPTION:
6959 
      x = TApplicationException()
6960 
      x.read(self._iprot)
6961 
      self._iprot.readMessageEnd()
6962 
      raise x
6963 
    result = createRechargeTransaction_result()
6964 
    result.read(self._iprot)
6965 
    self._iprot.readMessageEnd()
6966 
    if result.success is not None:
6967 
      return result.success
6968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6969 
 
7085 rajveer 6970 
  def getRechargeTransactions(self, storeId):
6971 
    """
6972 
    Parameters:
6973 
     - storeId
6974 
    """
6975 
    self.send_getRechargeTransactions(storeId)
6976 
    return self.recv_getRechargeTransactions()
6977 
 
6978 
  def send_getRechargeTransactions(self, storeId):
6979 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6980 
    args = getRechargeTransactions_args()
6981 
    args.storeId = storeId
6982 
    args.write(self._oprot)
6983 
    self._oprot.writeMessageEnd()
6984 
    self._oprot.trans.flush()
6985 
 
6986 
  def recv_getRechargeTransactions(self, ):
6987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6988 
    if mtype == TMessageType.EXCEPTION:
6989 
      x = TApplicationException()
6990 
      x.read(self._iprot)
6991 
      self._iprot.readMessageEnd()
6992 
      raise x
6993 
    result = getRechargeTransactions_result()
6994 
    result.read(self._iprot)
6995 
    self._iprot.readMessageEnd()
6996 
    if result.success is not None:
6997 
      return result.success
6998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6999 
 
7151 amit.gupta 7000 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
7001 
    """
7002 
    Parameters:
7003 
     - storeId
7004 
     - startDate
7005 
     - endDate
7006 
     - status
7007 
    """
7008 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
7009 
    return self.recv_getRechargeTrans()
7010 
 
7011 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
7012 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
7013 
    args = getRechargeTrans_args()
7014 
    args.storeId = storeId
7015 
    args.startDate = startDate
7016 
    args.endDate = endDate
7017 
    args.status = status
7018 
    args.write(self._oprot)
7019 
    self._oprot.writeMessageEnd()
7020 
    self._oprot.trans.flush()
7021 
 
7022 
  def recv_getRechargeTrans(self, ):
7023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7024 
    if mtype == TMessageType.EXCEPTION:
7025 
      x = TApplicationException()
7026 
      x.read(self._iprot)
7027 
      self._iprot.readMessageEnd()
7028 
      raise x
7029 
    result = getRechargeTrans_result()
7030 
    result.read(self._iprot)
7031 
    self._iprot.readMessageEnd()
7032 
    if result.success is not None:
7033 
      return result.success
7034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
7035 
 
7080 anupam.sin 7036 
  def getRechargeTransaction(self, rechargeId):
7037 
    """
7038 
    Parameters:
7039 
     - rechargeId
7040 
    """
7041 
    self.send_getRechargeTransaction(rechargeId)
7042 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 7043 
 
7080 anupam.sin 7044 
  def send_getRechargeTransaction(self, rechargeId):
7045 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
7046 
    args = getRechargeTransaction_args()
7047 
    args.rechargeId = rechargeId
7048 
    args.write(self._oprot)
7049 
    self._oprot.writeMessageEnd()
7050 
    self._oprot.trans.flush()
7051 
 
7052 
  def recv_getRechargeTransaction(self, ):
7053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7054 
    if mtype == TMessageType.EXCEPTION:
7055 
      x = TApplicationException()
7056 
      x.read(self._iprot)
7057 
      self._iprot.readMessageEnd()
7058 
      raise x
7059 
    result = getRechargeTransaction_result()
7060 
    result.read(self._iprot)
7061 
    self._iprot.readMessageEnd()
7062 
    if result.success is not None:
7063 
      return result.success
7064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
7065 
 
7066 
  def getFRCs(self, circleId, operatorId):
7067 
    """
7068 
    Parameters:
7069 
     - circleId
7070 
     - operatorId
7071 
    """
7072 
    self.send_getFRCs(circleId, operatorId)
7073 
    return self.recv_getFRCs()
7074 
 
7075 
  def send_getFRCs(self, circleId, operatorId):
7076 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
7077 
    args = getFRCs_args()
7078 
    args.circleId = circleId
7079 
    args.operatorId = operatorId
7080 
    args.write(self._oprot)
7081 
    self._oprot.writeMessageEnd()
7082 
    self._oprot.trans.flush()
7083 
 
7084 
  def recv_getFRCs(self, ):
7085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7086 
    if mtype == TMessageType.EXCEPTION:
7087 
      x = TApplicationException()
7088 
      x.read(self._iprot)
7089 
      self._iprot.readMessageEnd()
7090 
      raise x
7091 
    result = getFRCs_result()
7092 
    result.read(self._iprot)
7093 
    self._iprot.readMessageEnd()
7094 
    if result.success is not None:
7095 
      return result.success
7096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
7097 
 
7096 anupam.sin 7098 
  def getHotspotStore(self, id, hotspotid):
7099 
    """
7100 
    Parameters:
7101 
     - id
7102 
     - hotspotid
7103 
    """
7104 
    self.send_getHotspotStore(id, hotspotid)
7105 
    return self.recv_getHotspotStore()
7080 anupam.sin 7106 
 
7096 anupam.sin 7107 
  def send_getHotspotStore(self, id, hotspotid):
7108 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
7109 
    args = getHotspotStore_args()
7110 
    args.id = id
7111 
    args.hotspotid = hotspotid
7112 
    args.write(self._oprot)
7113 
    self._oprot.writeMessageEnd()
7114 
    self._oprot.trans.flush()
7115 
 
7116 
  def recv_getHotspotStore(self, ):
7117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7118 
    if mtype == TMessageType.EXCEPTION:
7119 
      x = TApplicationException()
7120 
      x.read(self._iprot)
7121 
      self._iprot.readMessageEnd()
7122 
      raise x
7123 
    result = getHotspotStore_result()
7124 
    result.read(self._iprot)
7125 
    self._iprot.readMessageEnd()
7126 
    if result.success is not None:
7127 
      return result.success
7128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
7129 
 
7130 
  def getTelecomCircle(self, id, code):
7131 
    """
7132 
    Parameters:
7133 
     - id
7134 
     - code
7135 
    """
7136 
    self.send_getTelecomCircle(id, code)
7137 
    return self.recv_getTelecomCircle()
7138 
 
7139 
  def send_getTelecomCircle(self, id, code):
7140 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7141 
    args = getTelecomCircle_args()
7142 
    args.id = id
7143 
    args.code = code
7144 
    args.write(self._oprot)
7145 
    self._oprot.writeMessageEnd()
7146 
    self._oprot.trans.flush()
7147 
 
7148 
  def recv_getTelecomCircle(self, ):
7149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7150 
    if mtype == TMessageType.EXCEPTION:
7151 
      x = TApplicationException()
7152 
      x.read(self._iprot)
7153 
      self._iprot.readMessageEnd()
7154 
      raise x
7155 
    result = getTelecomCircle_result()
7156 
    result.read(self._iprot)
7157 
    self._iprot.readMessageEnd()
7158 
    if result.success is not None:
7159 
      return result.success
7160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
7161 
 
7109 anupam.sin 7162 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7163 
    """
7164 
    Parameters:
7165 
     - rechargeId
7166 
    """
7167 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7168 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7169 
 
7109 anupam.sin 7170 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7171 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7172 
    args = retrieveHotspotRechargeInvoice_args()
7173 
    args.rechargeId = rechargeId
7174 
    args.write(self._oprot)
7175 
    self._oprot.writeMessageEnd()
7176 
    self._oprot.trans.flush()
7177 
 
7178 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7180 
    if mtype == TMessageType.EXCEPTION:
7181 
      x = TApplicationException()
7182 
      x.read(self._iprot)
7183 
      self._iprot.readMessageEnd()
7184 
      raise x
7185 
    result = retrieveHotspotRechargeInvoice_result()
7186 
    result.read(self._iprot)
7187 
    self._iprot.readMessageEnd()
7188 
    if result.success is not None:
7189 
      return result.success
7190 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7191 
 
7190 amar.kumar 7192 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
7193 
    """
7194 
    Parameters:
7195 
     - orderId
7196 
     - splitReason
7197 
     - shippingDate
7198 
    """
7199 
    self.send_splitFreebieOrder(orderId, splitReason, shippingDate)
7200 
    return self.recv_splitFreebieOrder()
7201 
 
7202 
  def send_splitFreebieOrder(self, orderId, splitReason, shippingDate):
7203 
    self._oprot.writeMessageBegin('splitFreebieOrder', TMessageType.CALL, self._seqid)
7204 
    args = splitFreebieOrder_args()
7205 
    args.orderId = orderId
7206 
    args.splitReason = splitReason
7207 
    args.shippingDate = shippingDate
7208 
    args.write(self._oprot)
7209 
    self._oprot.writeMessageEnd()
7210 
    self._oprot.trans.flush()
7211 
 
7212 
  def recv_splitFreebieOrder(self, ):
7213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7214 
    if mtype == TMessageType.EXCEPTION:
7215 
      x = TApplicationException()
7216 
      x.read(self._iprot)
7217 
      self._iprot.readMessageEnd()
7218 
      raise x
7219 
    result = splitFreebieOrder_result()
7220 
    result.read(self._iprot)
7221 
    self._iprot.readMessageEnd()
7222 
    if result.success is not None:
7223 
      return result.success
7224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "splitFreebieOrder failed: unknown result");
7225 
 
7172 anupam.sin 7226 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7227 
    """
7228 
    Parameters:
7229 
     - number
7172 anupam.sin 7230 
     - storeId
7169 anupam.sin 7231 
    """
7172 anupam.sin 7232 
    self.send_getRechargeTransactionsByNumber(number, storeId)
7169 anupam.sin 7233 
    return self.recv_getRechargeTransactionsByNumber()
7109 anupam.sin 7234 
 
7172 anupam.sin 7235 
  def send_getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7236 
    self._oprot.writeMessageBegin('getRechargeTransactionsByNumber', TMessageType.CALL, self._seqid)
7237 
    args = getRechargeTransactionsByNumber_args()
7238 
    args.number = number
7172 anupam.sin 7239 
    args.storeId = storeId
7169 anupam.sin 7240 
    args.write(self._oprot)
7241 
    self._oprot.writeMessageEnd()
7242 
    self._oprot.trans.flush()
7243 
 
7244 
  def recv_getRechargeTransactionsByNumber(self, ):
7245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7246 
    if mtype == TMessageType.EXCEPTION:
7247 
      x = TApplicationException()
7248 
      x.read(self._iprot)
7249 
      self._iprot.readMessageEnd()
7250 
      raise x
7251 
    result = getRechargeTransactionsByNumber_result()
7252 
    result.read(self._iprot)
7253 
    self._iprot.readMessageEnd()
7254 
    if result.success is not None:
7255 
      return result.success
7256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactionsByNumber failed: unknown result");
7257 
 
7258 
  def updateHotspotStorePassword(self, storeId, password):
7259 
    """
7260 
    Parameters:
7261 
     - storeId
7262 
     - password
7263 
    """
7264 
    self.send_updateHotspotStorePassword(storeId, password)
7265 
    return self.recv_updateHotspotStorePassword()
7266 
 
7267 
  def send_updateHotspotStorePassword(self, storeId, password):
7268 
    self._oprot.writeMessageBegin('updateHotspotStorePassword', TMessageType.CALL, self._seqid)
7269 
    args = updateHotspotStorePassword_args()
7270 
    args.storeId = storeId
7271 
    args.password = password
7272 
    args.write(self._oprot)
7273 
    self._oprot.writeMessageEnd()
7274 
    self._oprot.trans.flush()
7275 
 
7276 
  def recv_updateHotspotStorePassword(self, ):
7277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7278 
    if mtype == TMessageType.EXCEPTION:
7279 
      x = TApplicationException()
7280 
      x.read(self._iprot)
7281 
      self._iprot.readMessageEnd()
7282 
      raise x
7283 
    result = updateHotspotStorePassword_result()
7284 
    result.read(self._iprot)
7285 
    self._iprot.readMessageEnd()
7286 
    if result.success is not None:
7287 
      return result.success
7288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateHotspotStorePassword failed: unknown result");
7289 
 
7285 rajveer 7290 
  def topupCompanyWallet(self, companyId, amount):
7263 anupam.sin 7291 
    """
7292 
    Parameters:
7285 rajveer 7293 
     - companyId
7294 
     - amount
7263 anupam.sin 7295 
    """
7285 rajveer 7296 
    self.send_topupCompanyWallet(companyId, amount)
7297 
    return self.recv_topupCompanyWallet()
7169 anupam.sin 7298 
 
7285 rajveer 7299 
  def send_topupCompanyWallet(self, companyId, amount):
7300 
    self._oprot.writeMessageBegin('topupCompanyWallet', TMessageType.CALL, self._seqid)
7301 
    args = topupCompanyWallet_args()
7302 
    args.companyId = companyId
7303 
    args.amount = amount
7263 anupam.sin 7304 
    args.write(self._oprot)
7305 
    self._oprot.writeMessageEnd()
7306 
    self._oprot.trans.flush()
7307 
 
7285 rajveer 7308 
  def recv_topupCompanyWallet(self, ):
7263 anupam.sin 7309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7310 
    if mtype == TMessageType.EXCEPTION:
7311 
      x = TApplicationException()
7312 
      x.read(self._iprot)
7313 
      self._iprot.readMessageEnd()
7314 
      raise x
7285 rajveer 7315 
    result = topupCompanyWallet_result()
7263 anupam.sin 7316 
    result.read(self._iprot)
7317 
    self._iprot.readMessageEnd()
7318 
    if result.success is not None:
7319 
      return result.success
7285 rajveer 7320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "topupCompanyWallet failed: unknown result");
7263 anupam.sin 7321 
 
7285 rajveer 7322 
  def getWalletBalanceForCompany(self, companyId):
7323 
    """
7324 
    Parameters:
7325 
     - companyId
7326 
    """
7327 
    self.send_getWalletBalanceForCompany(companyId)
7328 
    return self.recv_getWalletBalanceForCompany()
7263 anupam.sin 7329 
 
7285 rajveer 7330 
  def send_getWalletBalanceForCompany(self, companyId):
7331 
    self._oprot.writeMessageBegin('getWalletBalanceForCompany', TMessageType.CALL, self._seqid)
7332 
    args = getWalletBalanceForCompany_args()
7333 
    args.companyId = companyId
7267 anupam.sin 7334 
    args.write(self._oprot)
7335 
    self._oprot.writeMessageEnd()
7336 
    self._oprot.trans.flush()
7337 
 
7285 rajveer 7338 
  def recv_getWalletBalanceForCompany(self, ):
7267 anupam.sin 7339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7340 
    if mtype == TMessageType.EXCEPTION:
7341 
      x = TApplicationException()
7342 
      x.read(self._iprot)
7343 
      self._iprot.readMessageEnd()
7344 
      raise x
7285 rajveer 7345 
    result = getWalletBalanceForCompany_result()
7267 anupam.sin 7346 
    result.read(self._iprot)
7347 
    self._iprot.readMessageEnd()
7348 
    if result.success is not None:
7349 
      return result.success
7285 rajveer 7350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWalletBalanceForCompany failed: unknown result");
7267 anupam.sin 7351 
 
7363 rajveer 7352 
  def getSaholicRechargeBalance(self, ):
7353 
    self.send_getSaholicRechargeBalance()
7354 
    return self.recv_getSaholicRechargeBalance()
7355 
 
7356 
  def send_getSaholicRechargeBalance(self, ):
7357 
    self._oprot.writeMessageBegin('getSaholicRechargeBalance', TMessageType.CALL, self._seqid)
7358 
    args = getSaholicRechargeBalance_args()
7359 
    args.write(self._oprot)
7360 
    self._oprot.writeMessageEnd()
7361 
    self._oprot.trans.flush()
7362 
 
7363 
  def recv_getSaholicRechargeBalance(self, ):
7364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7365 
    if mtype == TMessageType.EXCEPTION:
7366 
      x = TApplicationException()
7367 
      x.read(self._iprot)
7368 
      self._iprot.readMessageEnd()
7369 
      raise x
7370 
    result = getSaholicRechargeBalance_result()
7371 
    result.read(self._iprot)
7372 
    self._iprot.readMessageEnd()
7373 
    if result.success is not None:
7374 
      return result.success
7375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSaholicRechargeBalance failed: unknown result");
7376 
 
7285 rajveer 7377 
  def getSourceDetail(self, source):
7267 anupam.sin 7378 
    """
7379 
    Parameters:
7285 rajveer 7380 
     - source
7267 anupam.sin 7381 
    """
7285 rajveer 7382 
    self.send_getSourceDetail(source)
7383 
    return self.recv_getSourceDetail()
7267 anupam.sin 7384 
 
7285 rajveer 7385 
  def send_getSourceDetail(self, source):
7386 
    self._oprot.writeMessageBegin('getSourceDetail', TMessageType.CALL, self._seqid)
7387 
    args = getSourceDetail_args()
7388 
    args.source = source
7267 anupam.sin 7389 
    args.write(self._oprot)
7390 
    self._oprot.writeMessageEnd()
7391 
    self._oprot.trans.flush()
7392 
 
7285 rajveer 7393 
  def recv_getSourceDetail(self, ):
7267 anupam.sin 7394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7395 
    if mtype == TMessageType.EXCEPTION:
7396 
      x = TApplicationException()
7397 
      x.read(self._iprot)
7398 
      self._iprot.readMessageEnd()
7399 
      raise x
7285 rajveer 7400 
    result = getSourceDetail_result()
7267 anupam.sin 7401 
    result.read(self._iprot)
7402 
    self._iprot.readMessageEnd()
7403 
    if result.success is not None:
7404 
      return result.success
7285 rajveer 7405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSourceDetail failed: unknown result");
7267 anupam.sin 7406 
 
7308 rajveer 7407 
  def getAllCircles(self, ):
7408 
    self.send_getAllCircles()
7409 
    return self.recv_getAllCircles()
7267 anupam.sin 7410 
 
7308 rajveer 7411 
  def send_getAllCircles(self, ):
7412 
    self._oprot.writeMessageBegin('getAllCircles', TMessageType.CALL, self._seqid)
7413 
    args = getAllCircles_args()
7414 
    args.write(self._oprot)
7415 
    self._oprot.writeMessageEnd()
7416 
    self._oprot.trans.flush()
7417 
 
7418 
  def recv_getAllCircles(self, ):
7419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7420 
    if mtype == TMessageType.EXCEPTION:
7421 
      x = TApplicationException()
7422 
      x.read(self._iprot)
7423 
      self._iprot.readMessageEnd()
7424 
      raise x
7425 
    result = getAllCircles_result()
7426 
    result.read(self._iprot)
7427 
    self._iprot.readMessageEnd()
7428 
    if result.success is not None:
7429 
      return result.success
7430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCircles failed: unknown result");
7431 
 
7432 
  def deleteFrcs(self, frcIdsToDelete):
7433 
    """
7434 
    Parameters:
7435 
     - frcIdsToDelete
7436 
    """
7437 
    self.send_deleteFrcs(frcIdsToDelete)
7438 
    return self.recv_deleteFrcs()
7439 
 
7440 
  def send_deleteFrcs(self, frcIdsToDelete):
7441 
    self._oprot.writeMessageBegin('deleteFrcs', TMessageType.CALL, self._seqid)
7442 
    args = deleteFrcs_args()
7443 
    args.frcIdsToDelete = frcIdsToDelete
7444 
    args.write(self._oprot)
7445 
    self._oprot.writeMessageEnd()
7446 
    self._oprot.trans.flush()
7447 
 
7448 
  def recv_deleteFrcs(self, ):
7449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7450 
    if mtype == TMessageType.EXCEPTION:
7451 
      x = TApplicationException()
7452 
      x.read(self._iprot)
7453 
      self._iprot.readMessageEnd()
7454 
      raise x
7455 
    result = deleteFrcs_result()
7456 
    result.read(self._iprot)
7457 
    self._iprot.readMessageEnd()
7458 
    if result.success is not None:
7459 
      return result.success
7460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteFrcs failed: unknown result");
7461 
 
7311 kshitij.so 7462 
  def addAmazonOrder(self, amazonOrder):
7463 
    """
7464 
    Parameters:
7465 
     - amazonOrder
7466 
    """
7467 
    self.send_addAmazonOrder(amazonOrder)
7468 
    self.recv_addAmazonOrder()
7308 rajveer 7469 
 
7311 kshitij.so 7470 
  def send_addAmazonOrder(self, amazonOrder):
7471 
    self._oprot.writeMessageBegin('addAmazonOrder', TMessageType.CALL, self._seqid)
7472 
    args = addAmazonOrder_args()
7473 
    args.amazonOrder = amazonOrder
7474 
    args.write(self._oprot)
7475 
    self._oprot.writeMessageEnd()
7476 
    self._oprot.trans.flush()
7477 
 
7478 
  def recv_addAmazonOrder(self, ):
7479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7480 
    if mtype == TMessageType.EXCEPTION:
7481 
      x = TApplicationException()
7482 
      x.read(self._iprot)
7483 
      self._iprot.readMessageEnd()
7484 
      raise x
7485 
    result = addAmazonOrder_result()
7486 
    result.read(self._iprot)
7487 
    self._iprot.readMessageEnd()
7488 
    return
7489 
 
7322 vikram.rag 7490 
  def updateAmazonOrderStatus(self, orderId, status):
7311 kshitij.so 7491 
    """
7492 
    Parameters:
7493 
     - orderId
7494 
     - status
7495 
    """
7322 vikram.rag 7496 
    self.send_updateAmazonOrderStatus(orderId, status)
7497 
    return self.recv_updateAmazonOrderStatus()
7311 kshitij.so 7498 
 
7322 vikram.rag 7499 
  def send_updateAmazonOrderStatus(self, orderId, status):
7500 
    self._oprot.writeMessageBegin('updateAmazonOrderStatus', TMessageType.CALL, self._seqid)
7501 
    args = updateAmazonOrderStatus_args()
7311 kshitij.so 7502 
    args.orderId = orderId
7503 
    args.status = status
7504 
    args.write(self._oprot)
7505 
    self._oprot.writeMessageEnd()
7506 
    self._oprot.trans.flush()
7507 
 
7322 vikram.rag 7508 
  def recv_updateAmazonOrderStatus(self, ):
7311 kshitij.so 7509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7510 
    if mtype == TMessageType.EXCEPTION:
7511 
      x = TApplicationException()
7512 
      x.read(self._iprot)
7513 
      self._iprot.readMessageEnd()
7514 
      raise x
7322 vikram.rag 7515 
    result = updateAmazonOrderStatus_result()
7311 kshitij.so 7516 
    result.read(self._iprot)
7517 
    self._iprot.readMessageEnd()
7518 
    if result.success is not None:
7519 
      return result.success
7322 vikram.rag 7520 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonOrderStatus failed: unknown result");
7311 kshitij.so 7521 
 
7522 
  def getAmazonOrdersShipped(self, interval):
7523 
    """
7524 
    Parameters:
7525 
     - interval
7526 
    """
7527 
    self.send_getAmazonOrdersShipped(interval)
7528 
    return self.recv_getAmazonOrdersShipped()
7529 
 
7530 
  def send_getAmazonOrdersShipped(self, interval):
7531 
    self._oprot.writeMessageBegin('getAmazonOrdersShipped', TMessageType.CALL, self._seqid)
7532 
    args = getAmazonOrdersShipped_args()
7533 
    args.interval = interval
7534 
    args.write(self._oprot)
7535 
    self._oprot.writeMessageEnd()
7536 
    self._oprot.trans.flush()
7537 
 
7538 
  def recv_getAmazonOrdersShipped(self, ):
7539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7540 
    if mtype == TMessageType.EXCEPTION:
7541 
      x = TApplicationException()
7542 
      x.read(self._iprot)
7543 
      self._iprot.readMessageEnd()
7544 
      raise x
7545 
    result = getAmazonOrdersShipped_result()
7546 
    result.read(self._iprot)
7547 
    self._iprot.readMessageEnd()
7548 
    if result.success is not None:
7549 
      return result.success
7550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOrdersShipped failed: unknown result");
7551 
 
7552 
  def getAmazonOrdersCancelled(self, interval):
7553 
    """
7554 
    Parameters:
7555 
     - interval
7556 
    """
7557 
    self.send_getAmazonOrdersCancelled(interval)
7558 
    return self.recv_getAmazonOrdersCancelled()
7559 
 
7560 
  def send_getAmazonOrdersCancelled(self, interval):
7561 
    self._oprot.writeMessageBegin('getAmazonOrdersCancelled', TMessageType.CALL, self._seqid)
7562 
    args = getAmazonOrdersCancelled_args()
7563 
    args.interval = interval
7564 
    args.write(self._oprot)
7565 
    self._oprot.writeMessageEnd()
7566 
    self._oprot.trans.flush()
7567 
 
7568 
  def recv_getAmazonOrdersCancelled(self, ):
7569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7570 
    if mtype == TMessageType.EXCEPTION:
7571 
      x = TApplicationException()
7572 
      x.read(self._iprot)
7573 
      self._iprot.readMessageEnd()
7574 
      raise x
7575 
    result = getAmazonOrdersCancelled_result()
7576 
    result.read(self._iprot)
7577 
    self._iprot.readMessageEnd()
7578 
    if result.success is not None:
7579 
      return result.success
7580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOrdersCancelled failed: unknown result");
7581 
 
7322 vikram.rag 7582 
  def getAmazonOrder(self, orderId):
7583 
    """
7584 
    Parameters:
7585 
     - orderId
7586 
    """
7587 
    self.send_getAmazonOrder(orderId)
7588 
    return self.recv_getAmazonOrder()
7311 kshitij.so 7589 
 
7322 vikram.rag 7590 
  def send_getAmazonOrder(self, orderId):
7591 
    self._oprot.writeMessageBegin('getAmazonOrder', TMessageType.CALL, self._seqid)
7592 
    args = getAmazonOrder_args()
7593 
    args.orderId = orderId
7594 
    args.write(self._oprot)
7595 
    self._oprot.writeMessageEnd()
7596 
    self._oprot.trans.flush()
7597 
 
7598 
  def recv_getAmazonOrder(self, ):
7599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7600 
    if mtype == TMessageType.EXCEPTION:
7601 
      x = TApplicationException()
7602 
      x.read(self._iprot)
7603 
      self._iprot.readMessageEnd()
7604 
      raise x
7605 
    result = getAmazonOrder_result()
7606 
    result.read(self._iprot)
7607 
    self._iprot.readMessageEnd()
7608 
    if result.success is not None:
7609 
      return result.success
7610 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOrder failed: unknown result");
7611 
 
7343 anupam.sin 7612 
  def getOrdersForStore(self, id, storeId, startDate, endDate, statuses):
7613 
    """
7614 
    Parameters:
7615 
     - id
7616 
     - storeId
7617 
     - startDate
7618 
     - endDate
7619 
     - statuses
7620 
    """
7621 
    self.send_getOrdersForStore(id, storeId, startDate, endDate, statuses)
7622 
    return self.recv_getOrdersForStore()
7322 vikram.rag 7623 
 
7343 anupam.sin 7624 
  def send_getOrdersForStore(self, id, storeId, startDate, endDate, statuses):
7625 
    self._oprot.writeMessageBegin('getOrdersForStore', TMessageType.CALL, self._seqid)
7626 
    args = getOrdersForStore_args()
7627 
    args.id = id
7628 
    args.storeId = storeId
7629 
    args.startDate = startDate
7630 
    args.endDate = endDate
7631 
    args.statuses = statuses
7632 
    args.write(self._oprot)
7633 
    self._oprot.writeMessageEnd()
7634 
    self._oprot.trans.flush()
7635 
 
7636 
  def recv_getOrdersForStore(self, ):
7637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7638 
    if mtype == TMessageType.EXCEPTION:
7639 
      x = TApplicationException()
7640 
      x.read(self._iprot)
7641 
      self._iprot.readMessageEnd()
7642 
      raise x
7643 
    result = getOrdersForStore_result()
7644 
    result.read(self._iprot)
7645 
    self._iprot.readMessageEnd()
7646 
    if result.success is not None:
7647 
      return result.success
7648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForStore failed: unknown result");
7649 
 
7650 
  def getStoreOrderAdvanceInvoice(self, orderId):
7651 
    """
7652 
    Parameters:
7653 
     - orderId
7654 
    """
7655 
    self.send_getStoreOrderAdvanceInvoice(orderId)
7656 
    return self.recv_getStoreOrderAdvanceInvoice()
7657 
 
7658 
  def send_getStoreOrderAdvanceInvoice(self, orderId):
7659 
    self._oprot.writeMessageBegin('getStoreOrderAdvanceInvoice', TMessageType.CALL, self._seqid)
7660 
    args = getStoreOrderAdvanceInvoice_args()
7661 
    args.orderId = orderId
7662 
    args.write(self._oprot)
7663 
    self._oprot.writeMessageEnd()
7664 
    self._oprot.trans.flush()
7665 
 
7666 
  def recv_getStoreOrderAdvanceInvoice(self, ):
7667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7668 
    if mtype == TMessageType.EXCEPTION:
7669 
      x = TApplicationException()
7670 
      x.read(self._iprot)
7671 
      self._iprot.readMessageEnd()
7672 
      raise x
7673 
    result = getStoreOrderAdvanceInvoice_result()
7674 
    result.read(self._iprot)
7675 
    self._iprot.readMessageEnd()
7676 
    if result.success is not None:
7677 
      return result.success
7678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStoreOrderAdvanceInvoice failed: unknown result");
7679 
 
7680 
 
3376 rajveer 7681 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7682 
  def __init__(self, handler):
3376 rajveer 7683 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7684 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7685 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7686 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7687 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7688 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7689 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7690 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7691 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7692 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7693 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7694 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7695 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7696 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7697 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7698 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7699 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7700 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7701 
    self._processMap["createOrder"] = Processor.process_createOrder
7702 
    self._processMap["getOrder"] = Processor.process_getOrder
7703 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7704 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7705 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7706 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7707 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7708 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7709 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7710 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7711 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7712 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7713 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7714 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7715 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7716 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7717 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7718 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7719 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7720 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7721 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7722 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7723 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7724 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7725 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7726 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7727 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7728 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7729 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7730 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7731 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7732 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7733 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7734 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7735 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7736 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7737 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7738 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7739 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7740 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7741 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7742 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7743 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7744 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7745 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7746 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7747 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7748 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7749 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7750 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7751 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7752 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7753 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7754 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7755 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7756 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7757 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7758 
    self._processMap["changeItem"] = Processor.process_changeItem
7759 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7760 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7761 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7762 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7763 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7764 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7765 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7766 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7767 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7768 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7769 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7770 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7771 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7772 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7773 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7774 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7775 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7776 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7777 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7778 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7779 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7780 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7781 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7782 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7783 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7784 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7785 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7786 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7787 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7788 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7789 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7790 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7791 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7792 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7793 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7794 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7795 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7796 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7797 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7798 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7799 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7800 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7801 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7802 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7803 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7804 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7805 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7806 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7807 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7808 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7809 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7810 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7811 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7812 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7813 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7814 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7815 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7816 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7817 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7818 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7819 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7820 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7821 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7822 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7823 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7824 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7825 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7826 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7827 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7828 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7829 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7830 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7831 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7832 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7833 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7834 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7835 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7836 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7837 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7838 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7839 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7840 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7841 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7842 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7843 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7844 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
7190 amar.kumar 7845 
    self._processMap["splitFreebieOrder"] = Processor.process_splitFreebieOrder
7169 anupam.sin 7846 
    self._processMap["getRechargeTransactionsByNumber"] = Processor.process_getRechargeTransactionsByNumber
7847 
    self._processMap["updateHotspotStorePassword"] = Processor.process_updateHotspotStorePassword
7285 rajveer 7848 
    self._processMap["topupCompanyWallet"] = Processor.process_topupCompanyWallet
7849 
    self._processMap["getWalletBalanceForCompany"] = Processor.process_getWalletBalanceForCompany
7363 rajveer 7850 
    self._processMap["getSaholicRechargeBalance"] = Processor.process_getSaholicRechargeBalance
7263 anupam.sin 7851 
    self._processMap["getSourceDetail"] = Processor.process_getSourceDetail
7308 rajveer 7852 
    self._processMap["getAllCircles"] = Processor.process_getAllCircles
7853 
    self._processMap["deleteFrcs"] = Processor.process_deleteFrcs
7311 kshitij.so 7854 
    self._processMap["addAmazonOrder"] = Processor.process_addAmazonOrder
7322 vikram.rag 7855 
    self._processMap["updateAmazonOrderStatus"] = Processor.process_updateAmazonOrderStatus
7311 kshitij.so 7856 
    self._processMap["getAmazonOrdersShipped"] = Processor.process_getAmazonOrdersShipped
7857 
    self._processMap["getAmazonOrdersCancelled"] = Processor.process_getAmazonOrdersCancelled
7322 vikram.rag 7858 
    self._processMap["getAmazonOrder"] = Processor.process_getAmazonOrder
7343 anupam.sin 7859 
    self._processMap["getOrdersForStore"] = Processor.process_getOrdersForStore
7860 
    self._processMap["getStoreOrderAdvanceInvoice"] = Processor.process_getStoreOrderAdvanceInvoice
94 ashish 7861 
 
7862 
  def process(self, iprot, oprot):
7863 
    (name, type, seqid) = iprot.readMessageBegin()
7864 
    if name not in self._processMap:
7865 
      iprot.skip(TType.STRUCT)
7866 
      iprot.readMessageEnd()
7867 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7868 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7869 
      x.write(oprot)
7870 
      oprot.writeMessageEnd()
7871 
      oprot.trans.flush()
7872 
      return
7873 
    else:
7874 
      self._processMap[name](self, seqid, iprot, oprot)
7875 
    return True
7876 
 
7877 
  def process_createTransaction(self, seqid, iprot, oprot):
7878 
    args = createTransaction_args()
7879 
    args.read(iprot)
7880 
    iprot.readMessageEnd()
7881 
    result = createTransaction_result()
7882 
    try:
132 ashish 7883 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7884 
    except TransactionServiceException, ex:
7885 
      result.ex = ex
7886 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7887 
    result.write(oprot)
7888 
    oprot.writeMessageEnd()
7889 
    oprot.trans.flush()
7890 
 
7891 
  def process_getTransaction(self, seqid, iprot, oprot):
7892 
    args = getTransaction_args()
7893 
    args.read(iprot)
7894 
    iprot.readMessageEnd()
7895 
    result = getTransaction_result()
7896 
    try:
7897 
      result.success = self._handler.getTransaction(args.id)
7898 
    except TransactionServiceException, ex:
7899 
      result.ex = ex
7900 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7901 
    result.write(oprot)
7902 
    oprot.writeMessageEnd()
7903 
    oprot.trans.flush()
7904 
 
7905 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7906 
    args = getTransactionsForCustomer_args()
7907 
    args.read(iprot)
7908 
    iprot.readMessageEnd()
7909 
    result = getTransactionsForCustomer_result()
7910 
    try:
7911 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7912 
    except TransactionServiceException, ex:
7913 
      result.ex = ex
7914 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7915 
    result.write(oprot)
7916 
    oprot.writeMessageEnd()
7917 
    oprot.trans.flush()
7918 
 
132 ashish 7919 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7920 
    args = getTransactionsForShoppingCartId_args()
7921 
    args.read(iprot)
7922 
    iprot.readMessageEnd()
7923 
    result = getTransactionsForShoppingCartId_result()
7924 
    try:
7925 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7926 
    except TransactionServiceException, ex:
7927 
      result.ex = ex
7928 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7929 
    result.write(oprot)
7930 
    oprot.writeMessageEnd()
7931 
    oprot.trans.flush()
7932 
 
94 ashish 7933 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7934 
    args = getTransactionStatus_args()
7935 
    args.read(iprot)
7936 
    iprot.readMessageEnd()
7937 
    result = getTransactionStatus_result()
7938 
    try:
7939 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7940 
    except TransactionServiceException, ex:
7941 
      result.ex = ex
7942 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7943 
    result.write(oprot)
7944 
    oprot.writeMessageEnd()
7945 
    oprot.trans.flush()
7946 
 
7947 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7948 
    args = changeTransactionStatus_args()
7949 
    args.read(iprot)
7950 
    iprot.readMessageEnd()
7951 
    result = changeTransactionStatus_result()
7952 
    try:
7293 anupam.sin 7953 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType, args.source)
94 ashish 7954 
    except TransactionServiceException, ex:
7955 
      result.ex = ex
7956 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7957 
    result.write(oprot)
7958 
    oprot.writeMessageEnd()
7959 
    oprot.trans.flush()
7960 
 
1398 varun.gupt 7961 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7962 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7963 
    args.read(iprot)
7964 
    iprot.readMessageEnd()
1398 varun.gupt 7965 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7966 
    try:
1398 varun.gupt 7967 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7968 
    except TransactionServiceException, ex:
7969 
      result.ex = ex
1398 varun.gupt 7970 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7971 
    result.write(oprot)
7972 
    oprot.writeMessageEnd()
7973 
    oprot.trans.flush()
7974 
 
483 rajveer 7975 
  def process_getAllOrders(self, seqid, iprot, oprot):
7976 
    args = getAllOrders_args()
94 ashish 7977 
    args.read(iprot)
7978 
    iprot.readMessageEnd()
483 rajveer 7979 
    result = getAllOrders_result()
94 ashish 7980 
    try:
4801 anupam.sin 7981 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7982 
    except TransactionServiceException, ex:
7983 
      result.ex = ex
483 rajveer 7984 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7985 
    result.write(oprot)
7986 
    oprot.writeMessageEnd()
7987 
    oprot.trans.flush()
7988 
 
4133 chandransh 7989 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7990 
    args = getOrdersInBatch_args()
7991 
    args.read(iprot)
7992 
    iprot.readMessageEnd()
7993 
    result = getOrdersInBatch_result()
7994 
    try:
7995 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7996 
    except TransactionServiceException, ex:
7997 
      result.ex = ex
7998 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7999 
    result.write(oprot)
8000 
    oprot.writeMessageEnd()
8001 
    oprot.trans.flush()
8002 
 
8003 
  def process_getOrderCount(self, seqid, iprot, oprot):
8004 
    args = getOrderCount_args()
8005 
    args.read(iprot)
8006 
    iprot.readMessageEnd()
8007 
    result = getOrderCount_result()
8008 
    try:
8009 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
8010 
    except TransactionServiceException, ex:
8011 
      result.ex = ex
8012 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
8013 
    result.write(oprot)
8014 
    oprot.writeMessageEnd()
8015 
    oprot.trans.flush()
8016 
 
999 varun.gupt 8017 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
8018 
    args = getOrdersByBillingDate_args()
8019 
    args.read(iprot)
8020 
    iprot.readMessageEnd()
8021 
    result = getOrdersByBillingDate_result()
8022 
    try:
8023 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
8024 
    except TransactionServiceException, ex:
8025 
      result.ex = ex
8026 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
8027 
    result.write(oprot)
8028 
    oprot.writeMessageEnd()
8029 
    oprot.trans.flush()
8030 
 
3427 chandransh 8031 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
8032 
    args = getOrdersByShippingDate_args()
8033 
    args.read(iprot)
8034 
    iprot.readMessageEnd()
8035 
    result = getOrdersByShippingDate_result()
8036 
    try:
3451 chandransh 8037 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 8038 
    except TransactionServiceException, ex:
8039 
      result.ex = ex
8040 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
8041 
    result.write(oprot)
8042 
    oprot.writeMessageEnd()
8043 
    oprot.trans.flush()
8044 
 
1382 varun.gupt 8045 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
8046 
    args = getReturnableOrdersForCustomer_args()
8047 
    args.read(iprot)
8048 
    iprot.readMessageEnd()
8049 
    result = getReturnableOrdersForCustomer_result()
8050 
    try:
8051 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
8052 
    except TransactionServiceException, ex:
8053 
      result.ex = ex
8054 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
8055 
    result.write(oprot)
8056 
    oprot.writeMessageEnd()
8057 
    oprot.trans.flush()
8058 
 
8059 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
8060 
    args = getCancellableOrdersForCustomer_args()
8061 
    args.read(iprot)
8062 
    iprot.readMessageEnd()
8063 
    result = getCancellableOrdersForCustomer_result()
8064 
    try:
8065 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
8066 
    except TransactionServiceException, ex:
8067 
      result.ex = ex
8068 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
8069 
    result.write(oprot)
8070 
    oprot.writeMessageEnd()
8071 
    oprot.trans.flush()
8072 
 
483 rajveer 8073 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
8074 
    args = changeOrderStatus_args()
94 ashish 8075 
    args.read(iprot)
8076 
    iprot.readMessageEnd()
483 rajveer 8077 
    result = changeOrderStatus_result()
94 ashish 8078 
    try:
483 rajveer 8079 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 8080 
    except TransactionServiceException, ex:
8081 
      result.ex = ex
483 rajveer 8082 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 8083 
    result.write(oprot)
8084 
    oprot.writeMessageEnd()
8085 
    oprot.trans.flush()
8086 
 
483 rajveer 8087 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
8088 
    args = getOrdersForTransaction_args()
94 ashish 8089 
    args.read(iprot)
8090 
    iprot.readMessageEnd()
483 rajveer 8091 
    result = getOrdersForTransaction_result()
94 ashish 8092 
    try:
1528 ankur.sing 8093 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 8094 
    except TransactionServiceException, ex:
8095 
      result.ex = ex
483 rajveer 8096 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 8097 
    result.write(oprot)
8098 
    oprot.writeMessageEnd()
8099 
    oprot.trans.flush()
8100 
 
483 rajveer 8101 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
8102 
    args = getOrdersForCustomer_args()
94 ashish 8103 
    args.read(iprot)
8104 
    iprot.readMessageEnd()
483 rajveer 8105 
    result = getOrdersForCustomer_result()
94 ashish 8106 
    try:
3014 chandransh 8107 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 8108 
    except TransactionServiceException, ex:
8109 
      result.ex = ex
483 rajveer 8110 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 8111 
    result.write(oprot)
8112 
    oprot.writeMessageEnd()
8113 
    oprot.trans.flush()
8114 
 
483 rajveer 8115 
  def process_createOrder(self, seqid, iprot, oprot):
8116 
    args = createOrder_args()
94 ashish 8117 
    args.read(iprot)
8118 
    iprot.readMessageEnd()
483 rajveer 8119 
    result = createOrder_result()
94 ashish 8120 
    try:
483 rajveer 8121 
      result.success = self._handler.createOrder(args.order)
94 ashish 8122 
    except TransactionServiceException, ex:
8123 
      result.ex = ex
483 rajveer 8124 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 8125 
    result.write(oprot)
8126 
    oprot.writeMessageEnd()
8127 
    oprot.trans.flush()
8128 
 
483 rajveer 8129 
  def process_getOrder(self, seqid, iprot, oprot):
8130 
    args = getOrder_args()
94 ashish 8131 
    args.read(iprot)
8132 
    iprot.readMessageEnd()
483 rajveer 8133 
    result = getOrder_result()
94 ashish 8134 
    try:
483 rajveer 8135 
      result.success = self._handler.getOrder(args.id)
94 ashish 8136 
    except TransactionServiceException, ex:
8137 
      result.ex = ex
483 rajveer 8138 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 8139 
    result.write(oprot)
8140 
    oprot.writeMessageEnd()
8141 
    oprot.trans.flush()
8142 
 
483 rajveer 8143 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
8144 
    args = getLineItemsForOrder_args()
94 ashish 8145 
    args.read(iprot)
8146 
    iprot.readMessageEnd()
483 rajveer 8147 
    result = getLineItemsForOrder_result()
94 ashish 8148 
    try:
483 rajveer 8149 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 8150 
    except TransactionServiceException, ex:
8151 
      result.ex = ex
483 rajveer 8152 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 8153 
    result.write(oprot)
8154 
    oprot.writeMessageEnd()
8155 
    oprot.trans.flush()
8156 
 
4999 phani.kuma 8157 
  def process_getOrderList(self, seqid, iprot, oprot):
8158 
    args = getOrderList_args()
8159 
    args.read(iprot)
8160 
    iprot.readMessageEnd()
8161 
    result = getOrderList_result()
8162 
    result.success = self._handler.getOrderList(args.order_ids)
8163 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
8164 
    result.write(oprot)
8165 
    oprot.writeMessageEnd()
8166 
    oprot.trans.flush()
8167 
 
5386 phani.kuma 8168 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
8169 
    args = getOrderListForVendor_args()
8170 
    args.read(iprot)
8171 
    iprot.readMessageEnd()
8172 
    result = getOrderListForVendor_result()
8173 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
8174 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
8175 
    result.write(oprot)
8176 
    oprot.writeMessageEnd()
8177 
    oprot.trans.flush()
8178 
 
1528 ankur.sing 8179 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
8180 
    args = getOrderForCustomer_args()
8181 
    args.read(iprot)
8182 
    iprot.readMessageEnd()
8183 
    result = getOrderForCustomer_result()
8184 
    try:
8185 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
8186 
    except TransactionServiceException, ex:
8187 
      result.ex = ex
8188 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
8189 
    result.write(oprot)
8190 
    oprot.writeMessageEnd()
8191 
    oprot.trans.flush()
8192 
 
3064 chandransh 8193 
  def process_getAlerts(self, seqid, iprot, oprot):
8194 
    args = getAlerts_args()
8195 
    args.read(iprot)
8196 
    iprot.readMessageEnd()
8197 
    result = getAlerts_result()
4444 rajveer 8198 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 8199 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
8200 
    result.write(oprot)
8201 
    oprot.writeMessageEnd()
8202 
    oprot.trans.flush()
8203 
 
4394 rajveer 8204 
  def process_addAlert(self, seqid, iprot, oprot):
8205 
    args = addAlert_args()
3064 chandransh 8206 
    args.read(iprot)
8207 
    iprot.readMessageEnd()
4394 rajveer 8208 
    result = addAlert_result()
4444 rajveer 8209 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 8210 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 8211 
    result.write(oprot)
8212 
    oprot.writeMessageEnd()
8213 
    oprot.trans.flush()
8214 
 
4444 rajveer 8215 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
8216 
    args = markAlertsAsSeen_args()
8217 
    args.read(iprot)
8218 
    iprot.readMessageEnd()
8219 
    result = markAlertsAsSeen_result()
8220 
    self._handler.markAlertsAsSeen(args.warehouseId)
8221 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
8222 
    result.write(oprot)
8223 
    oprot.writeMessageEnd()
8224 
    oprot.trans.flush()
8225 
 
3064 chandransh 8226 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
8227 
    args = getValidOrderCount_args()
8228 
    args.read(iprot)
8229 
    iprot.readMessageEnd()
8230 
    result = getValidOrderCount_result()
8231 
    result.success = self._handler.getValidOrderCount()
8232 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
8233 
    result.write(oprot)
8234 
    oprot.writeMessageEnd()
8235 
    oprot.trans.flush()
8236 
 
8237 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
8238 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
8239 
    args.read(iprot)
8240 
    iprot.readMessageEnd()
8241 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
8242 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
8243 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
8244 
    result.write(oprot)
8245 
    oprot.writeMessageEnd()
8246 
    oprot.trans.flush()
8247 
 
8248 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
8249 
    args = getValidOrdersAmountRange_args()
8250 
    args.read(iprot)
8251 
    iprot.readMessageEnd()
8252 
    result = getValidOrdersAmountRange_result()
8253 
    result.success = self._handler.getValidOrdersAmountRange()
8254 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
8255 
    result.write(oprot)
8256 
    oprot.writeMessageEnd()
8257 
    oprot.trans.flush()
8258 
 
8259 
  def process_getValidOrders(self, seqid, iprot, oprot):
8260 
    args = getValidOrders_args()
8261 
    args.read(iprot)
8262 
    iprot.readMessageEnd()
8263 
    result = getValidOrders_result()
5874 rajveer 8264 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 8265 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
8266 
    result.write(oprot)
8267 
    oprot.writeMessageEnd()
8268 
    oprot.trans.flush()
8269 
 
1220 chandransh 8270 
  def process_batchOrders(self, seqid, iprot, oprot):
8271 
    args = batchOrders_args()
8272 
    args.read(iprot)
8273 
    iprot.readMessageEnd()
8274 
    result = batchOrders_result()
8275 
    try:
8276 
      result.success = self._handler.batchOrders(args.warehouseId)
8277 
    except TransactionServiceException, ex:
8278 
      result.ex = ex
8279 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
8280 
    result.write(oprot)
8281 
    oprot.writeMessageEnd()
8282 
    oprot.trans.flush()
8283 
 
1208 chandransh 8284 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
8285 
    args = markOrderAsOutOfStock_args()
8286 
    args.read(iprot)
8287 
    iprot.readMessageEnd()
8288 
    result = markOrderAsOutOfStock_result()
8289 
    try:
8290 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
8291 
    except TransactionServiceException, ex:
8292 
      result.ex = ex
8293 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
8294 
    result.write(oprot)
8295 
    oprot.writeMessageEnd()
8296 
    oprot.trans.flush()
8297 
 
3064 chandransh 8298 
  def process_verifyOrder(self, seqid, iprot, oprot):
8299 
    args = verifyOrder_args()
759 chandransh 8300 
    args.read(iprot)
8301 
    iprot.readMessageEnd()
3064 chandransh 8302 
    result = verifyOrder_result()
759 chandransh 8303 
    try:
3064 chandransh 8304 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 8305 
    except TransactionServiceException, ex:
8306 
      result.ex = ex
3064 chandransh 8307 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 8308 
    result.write(oprot)
8309 
    oprot.writeMessageEnd()
8310 
    oprot.trans.flush()
8311 
 
3064 chandransh 8312 
  def process_acceptOrder(self, seqid, iprot, oprot):
8313 
    args = acceptOrder_args()
1113 chandransh 8314 
    args.read(iprot)
8315 
    iprot.readMessageEnd()
3064 chandransh 8316 
    result = acceptOrder_result()
1113 chandransh 8317 
    try:
3064 chandransh 8318 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 8319 
    except TransactionServiceException, ex:
8320 
      result.ex = ex
3064 chandransh 8321 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 8322 
    result.write(oprot)
8323 
    oprot.writeMessageEnd()
8324 
    oprot.trans.flush()
8325 
 
3064 chandransh 8326 
  def process_addBillingDetails(self, seqid, iprot, oprot):
8327 
    args = addBillingDetails_args()
1135 chandransh 8328 
    args.read(iprot)
8329 
    iprot.readMessageEnd()
3064 chandransh 8330 
    result = addBillingDetails_result()
1135 chandransh 8331 
    try:
7190 amar.kumar 8332 
      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 8333 
    except TransactionServiceException, ex:
8334 
      result.ex = ex
3064 chandransh 8335 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 8336 
    result.write(oprot)
8337 
    oprot.writeMessageEnd()
8338 
    oprot.trans.flush()
8339 
 
4579 rajveer 8340 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
8341 
    args = addInvoiceNumber_args()
8342 
    args.read(iprot)
8343 
    iprot.readMessageEnd()
8344 
    result = addInvoiceNumber_result()
8345 
    try:
6756 amar.kumar 8346 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 8347 
    except TransactionServiceException, ex:
8348 
      result.ex = ex
8349 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
8350 
    result.write(oprot)
8351 
    oprot.writeMessageEnd()
8352 
    oprot.trans.flush()
8353 
 
4410 rajveer 8354 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
8355 
    args = markOrdersAsShippedFromWarehouse_args()
8356 
    args.read(iprot)
8357 
    iprot.readMessageEnd()
8358 
    result = markOrdersAsShippedFromWarehouse_result()
8359 
    try:
4789 rajveer 8360 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 8361 
    except TransactionServiceException, ex:
8362 
      result.ex = ex
8363 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
8364 
    result.write(oprot)
8365 
    oprot.writeMessageEnd()
8366 
    oprot.trans.flush()
8367 
 
5676 rajveer 8368 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
8369 
    args = markOrdersAsReturnedFromStore_args()
8370 
    args.read(iprot)
8371 
    iprot.readMessageEnd()
8372 
    result = markOrdersAsReturnedFromStore_result()
8373 
    try:
5713 rajveer 8374 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 8375 
    except TransactionServiceException, ex:
8376 
      result.ex = ex
8377 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
8378 
    result.write(oprot)
8379 
    oprot.writeMessageEnd()
8380 
    oprot.trans.flush()
8381 
 
3064 chandransh 8382 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
8383 
    args = markOrdersAsPickedUp_args()
304 ashish 8384 
    args.read(iprot)
8385 
    iprot.readMessageEnd()
3064 chandransh 8386 
    result = markOrdersAsPickedUp_result()
8387 
    try:
4910 phani.kuma 8388 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 8389 
    except TransactionServiceException, ex:
8390 
      result.ex = ex
8391 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 8392 
    result.write(oprot)
8393 
    oprot.writeMessageEnd()
8394 
    oprot.trans.flush()
94 ashish 8395 
 
4910 phani.kuma 8396 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
8397 
    args = getOrdersNotPickedUp_args()
8398 
    args.read(iprot)
8399 
    iprot.readMessageEnd()
8400 
    result = getOrdersNotPickedUp_result()
8401 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
8402 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
8403 
    result.write(oprot)
8404 
    oprot.writeMessageEnd()
8405 
    oprot.trans.flush()
8406 
 
3064 chandransh 8407 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
8408 
    args = markOrdersAsDelivered_args()
304 ashish 8409 
    args.read(iprot)
8410 
    iprot.readMessageEnd()
3064 chandransh 8411 
    result = markOrdersAsDelivered_result()
8412 
    try:
8413 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
8414 
    except TransactionServiceException, ex:
8415 
      result.ex = ex
8416 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 8417 
    result.write(oprot)
8418 
    oprot.writeMessageEnd()
8419 
    oprot.trans.flush()
8420 
 
4910 phani.kuma 8421 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
8422 
    args = markAsRTOrders_args()
1596 ankur.sing 8423 
    args.read(iprot)
8424 
    iprot.readMessageEnd()
4910 phani.kuma 8425 
    result = markAsRTOrders_result()
3064 chandransh 8426 
    try:
4910 phani.kuma 8427 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 8428 
    except TransactionServiceException, ex:
8429 
      result.ex = ex
4910 phani.kuma 8430 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 8431 
    result.write(oprot)
8432 
    oprot.writeMessageEnd()
8433 
    oprot.trans.flush()
304 ashish 8434 
 
4910 phani.kuma 8435 
  def process_getRTOrders(self, seqid, iprot, oprot):
8436 
    args = getRTOrders_args()
8437 
    args.read(iprot)
8438 
    iprot.readMessageEnd()
8439 
    result = getRTOrders_result()
8440 
    result.success = self._handler.getRTOrders(args.providerId)
8441 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
8442 
    result.write(oprot)
8443 
    oprot.writeMessageEnd()
8444 
    oprot.trans.flush()
8445 
 
3064 chandransh 8446 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
8447 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 8448 
    args.read(iprot)
8449 
    iprot.readMessageEnd()
3064 chandransh 8450 
    result = updateNonDeliveryReason_result()
8451 
    try:
4910 phani.kuma 8452 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 8453 
    except TransactionServiceException, ex:
8454 
      result.ex = ex
8455 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 8456 
    result.write(oprot)
8457 
    oprot.writeMessageEnd()
8458 
    oprot.trans.flush()
1596 ankur.sing 8459 
 
4910 phani.kuma 8460 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
8461 
    args = getNonDeliveredOrdersbyCourier_args()
8462 
    args.read(iprot)
8463 
    iprot.readMessageEnd()
8464 
    result = getNonDeliveredOrdersbyCourier_result()
8465 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
8466 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
8467 
    result.write(oprot)
8468 
    oprot.writeMessageEnd()
8469 
    oprot.trans.flush()
8470 
 
8471 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
8472 
    args = markOrdersAsLocalConnected_args()
8473 
    args.read(iprot)
8474 
    iprot.readMessageEnd()
8475 
    result = markOrdersAsLocalConnected_result()
8476 
    try:
8477 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
8478 
    except TransactionServiceException, ex:
8479 
      result.ex = ex
8480 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
8481 
    result.write(oprot)
8482 
    oprot.writeMessageEnd()
8483 
    oprot.trans.flush()
8484 
 
8485 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
8486 
    args = getOrdersNotLocalConnected_args()
8487 
    args.read(iprot)
8488 
    iprot.readMessageEnd()
8489 
    result = getOrdersNotLocalConnected_result()
8490 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
8491 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
8492 
    result.write(oprot)
8493 
    oprot.writeMessageEnd()
8494 
    oprot.trans.flush()
8495 
 
8496 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
8497 
    args = markOrdersAsDestinationCityReached_args()
8498 
    args.read(iprot)
8499 
    iprot.readMessageEnd()
8500 
    result = markOrdersAsDestinationCityReached_result()
8501 
    try:
8502 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
8503 
    except TransactionServiceException, ex:
8504 
      result.ex = ex
8505 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
8506 
    result.write(oprot)
8507 
    oprot.writeMessageEnd()
8508 
    oprot.trans.flush()
8509 
 
8510 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
8511 
    args = markOrdersAsFirstDeliveryAttempted_args()
8512 
    args.read(iprot)
8513 
    iprot.readMessageEnd()
8514 
    result = markOrdersAsFirstDeliveryAttempted_result()
8515 
    try:
8516 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
8517 
    except TransactionServiceException, ex:
8518 
      result.ex = ex
8519 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
8520 
    result.write(oprot)
8521 
    oprot.writeMessageEnd()
8522 
    oprot.trans.flush()
8523 
 
3064 chandransh 8524 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
8525 
    args = getUndeliveredOrders_args()
1627 ankur.sing 8526 
    args.read(iprot)
8527 
    iprot.readMessageEnd()
3064 chandransh 8528 
    result = getUndeliveredOrders_result()
8529 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
8530 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 8531 
    result.write(oprot)
8532 
    oprot.writeMessageEnd()
8533 
    oprot.trans.flush()
8534 
 
4783 phani.kuma 8535 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
8536 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
8537 
    args.read(iprot)
8538 
    iprot.readMessageEnd()
8539 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
8540 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
8541 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
8542 
    result.write(oprot)
8543 
    oprot.writeMessageEnd()
8544 
    oprot.trans.flush()
8545 
 
2536 chandransh 8546 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
8547 
    args = toggleDOAFlag_args()
8548 
    args.read(iprot)
8549 
    iprot.readMessageEnd()
8550 
    result = toggleDOAFlag_result()
8551 
    try:
8552 
      result.success = self._handler.toggleDOAFlag(args.orderId)
8553 
    except TransactionServiceException, ex:
8554 
      result.ex = ex
8555 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
8556 
    result.write(oprot)
8557 
    oprot.writeMessageEnd()
8558 
    oprot.trans.flush()
1886 ankur.sing 8559 
 
4712 rajveer 8560 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
8561 
    args = markOrderAsDelivered_args()
8562 
    args.read(iprot)
8563 
    iprot.readMessageEnd()
8564 
    result = markOrderAsDelivered_result()
8565 
    try:
8566 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
8567 
    except TransactionServiceException, ex:
8568 
      result.ex = ex
8569 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
8570 
    result.write(oprot)
8571 
    oprot.writeMessageEnd()
8572 
    oprot.trans.flush()
8573 
 
5553 rajveer 8574 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
8575 
    args = markOrderAsReceivedAtStore_args()
8576 
    args.read(iprot)
8577 
    iprot.readMessageEnd()
8578 
    result = markOrderAsReceivedAtStore_result()
8579 
    try:
8580 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
8581 
    except TransactionServiceException, ex:
8582 
      result.ex = ex
8583 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
8584 
    result.write(oprot)
8585 
    oprot.writeMessageEnd()
8586 
    oprot.trans.flush()
8587 
 
4454 rajveer 8588 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
8589 
    args = markOrderDoaRequestReceived_args()
8590 
    args.read(iprot)
8591 
    iprot.readMessageEnd()
8592 
    result = markOrderDoaRequestReceived_result()
8593 
    try:
8594 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
8595 
    except TransactionServiceException, ex:
8596 
      result.ex = ex
8597 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
8598 
    result.write(oprot)
8599 
    oprot.writeMessageEnd()
8600 
    oprot.trans.flush()
8601 
 
8602 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
8603 
    args = markOrderDoaRequestAuthorized_args()
8604 
    args.read(iprot)
8605 
    iprot.readMessageEnd()
8606 
    result = markOrderDoaRequestAuthorized_result()
8607 
    try:
8608 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
8609 
    except TransactionServiceException, ex:
8610 
      result.ex = ex
8611 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
8612 
    result.write(oprot)
8613 
    oprot.writeMessageEnd()
8614 
    oprot.trans.flush()
8615 
 
4488 rajveer 8616 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
8617 
    args = markOrderReturnRequestReceived_args()
8618 
    args.read(iprot)
8619 
    iprot.readMessageEnd()
8620 
    result = markOrderReturnRequestReceived_result()
8621 
    try:
8622 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
8623 
    except TransactionServiceException, ex:
8624 
      result.ex = ex
8625 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8626 
    result.write(oprot)
8627 
    oprot.writeMessageEnd()
8628 
    oprot.trans.flush()
8629 
 
8630 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8631 
    args = markOrderReturnRequestAuthorized_args()
8632 
    args.read(iprot)
8633 
    iprot.readMessageEnd()
8634 
    result = markOrderReturnRequestAuthorized_result()
8635 
    try:
8636 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8637 
    except TransactionServiceException, ex:
8638 
      result.ex = ex
8639 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8640 
    result.write(oprot)
8641 
    oprot.writeMessageEnd()
8642 
    oprot.trans.flush()
8643 
 
2536 chandransh 8644 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8645 
    args = requestPickupNumber_args()
8646 
    args.read(iprot)
8647 
    iprot.readMessageEnd()
8648 
    result = requestPickupNumber_result()
8649 
    try:
4579 rajveer 8650 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8651 
    except TransactionServiceException, ex:
8652 
      result.ex = ex
8653 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8654 
    result.write(oprot)
8655 
    oprot.writeMessageEnd()
8656 
    oprot.trans.flush()
8657 
 
8658 
  def process_authorizePickup(self, seqid, iprot, oprot):
8659 
    args = authorizePickup_args()
8660 
    args.read(iprot)
8661 
    iprot.readMessageEnd()
8662 
    result = authorizePickup_result()
8663 
    try:
4602 rajveer 8664 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8665 
    except TransactionServiceException, ex:
8666 
      result.ex = ex
8667 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8668 
    result.write(oprot)
8669 
    oprot.writeMessageEnd()
8670 
    oprot.trans.flush()
8671 
 
2764 chandransh 8672 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8673 
    args = markDoasAsPickedUp_args()
8674 
    args.read(iprot)
8675 
    iprot.readMessageEnd()
8676 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8677 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8678 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8679 
    result.write(oprot)
8680 
    oprot.writeMessageEnd()
8681 
    oprot.trans.flush()
8682 
 
4910 phani.kuma 8683 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8684 
    args = getDoasNotPickedUp_args()
8685 
    args.read(iprot)
8686 
    iprot.readMessageEnd()
8687 
    result = getDoasNotPickedUp_result()
8688 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8689 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8690 
    result.write(oprot)
8691 
    oprot.writeMessageEnd()
8692 
    oprot.trans.flush()
8693 
 
4741 phani.kuma 8694 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8695 
    args = markReturnOrdersAsPickedUp_args()
8696 
    args.read(iprot)
8697 
    iprot.readMessageEnd()
8698 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8699 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8700 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8701 
    result.write(oprot)
8702 
    oprot.writeMessageEnd()
8703 
    oprot.trans.flush()
8704 
 
4910 phani.kuma 8705 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8706 
    args = getReturnOrdersNotPickedUp_args()
8707 
    args.read(iprot)
8708 
    iprot.readMessageEnd()
8709 
    result = getReturnOrdersNotPickedUp_result()
8710 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8711 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8712 
    result.write(oprot)
8713 
    oprot.writeMessageEnd()
8714 
    oprot.trans.flush()
8715 
 
2616 chandransh 8716 
  def process_receiveReturn(self, seqid, iprot, oprot):
8717 
    args = receiveReturn_args()
2591 chandransh 8718 
    args.read(iprot)
8719 
    iprot.readMessageEnd()
2616 chandransh 8720 
    result = receiveReturn_result()
2591 chandransh 8721 
    try:
4479 rajveer 8722 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8723 
    except TransactionServiceException, ex:
8724 
      result.ex = ex
2616 chandransh 8725 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8726 
    result.write(oprot)
8727 
    oprot.writeMessageEnd()
8728 
    oprot.trans.flush()
2536 chandransh 8729 
 
2591 chandransh 8730 
  def process_validateDoa(self, seqid, iprot, oprot):
8731 
    args = validateDoa_args()
8732 
    args.read(iprot)
8733 
    iprot.readMessageEnd()
8734 
    result = validateDoa_result()
8735 
    try:
8736 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8737 
    except TransactionServiceException, ex:
8738 
      result.ex = ex
8739 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8740 
    result.write(oprot)
8741 
    oprot.writeMessageEnd()
8742 
    oprot.trans.flush()
8743 
 
4495 rajveer 8744 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8745 
    args = validateReturnProduct_args()
8746 
    args.read(iprot)
8747 
    iprot.readMessageEnd()
8748 
    result = validateReturnProduct_result()
8749 
    try:
8750 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8751 
    except TransactionServiceException, ex:
8752 
      result.ex = ex
8753 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8754 
    result.write(oprot)
8755 
    oprot.writeMessageEnd()
8756 
    oprot.trans.flush()
8757 
 
2616 chandransh 8758 
  def process_reshipOrder(self, seqid, iprot, oprot):
8759 
    args = reshipOrder_args()
8760 
    args.read(iprot)
8761 
    iprot.readMessageEnd()
8762 
    result = reshipOrder_result()
8763 
    try:
8764 
      result.success = self._handler.reshipOrder(args.orderId)
8765 
    except TransactionServiceException, ex:
8766 
      result.ex = ex
8767 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8768 
    result.write(oprot)
8769 
    oprot.writeMessageEnd()
8770 
    oprot.trans.flush()
2591 chandransh 8771 
 
2616 chandransh 8772 
  def process_refundOrder(self, seqid, iprot, oprot):
8773 
    args = refundOrder_args()
8774 
    args.read(iprot)
8775 
    iprot.readMessageEnd()
8776 
    result = refundOrder_result()
8777 
    try:
3226 chandransh 8778 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8779 
    except TransactionServiceException, ex:
8780 
      result.ex = ex
8781 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8782 
    result.write(oprot)
8783 
    oprot.writeMessageEnd()
8784 
    oprot.trans.flush()
8785 
 
2690 chandransh 8786 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8787 
    args = getReturnOrders_args()
8788 
    args.read(iprot)
8789 
    iprot.readMessageEnd()
8790 
    result = getReturnOrders_result()
8791 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8792 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8793 
    result.write(oprot)
8794 
    oprot.writeMessageEnd()
8795 
    oprot.trans.flush()
2616 chandransh 8796 
 
5481 phani.kuma 8797 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8798 
    args = getAllReturnOrders_args()
8799 
    args.read(iprot)
8800 
    iprot.readMessageEnd()
8801 
    result = getAllReturnOrders_result()
8802 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8803 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8804 
    result.write(oprot)
8805 
    oprot.writeMessageEnd()
8806 
    oprot.trans.flush()
8807 
 
2700 chandransh 8808 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8809 
    args = getReturnOrder_args()
8810 
    args.read(iprot)
8811 
    iprot.readMessageEnd()
8812 
    result = getReturnOrder_result()
8813 
    try:
8814 
      result.success = self._handler.getReturnOrder(args.id)
8815 
    except TransactionServiceException, ex:
8816 
      result.ex = ex
8817 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8818 
    result.write(oprot)
8819 
    oprot.writeMessageEnd()
8820 
    oprot.trans.flush()
8821 
 
2690 chandransh 8822 
  def process_processReturn(self, seqid, iprot, oprot):
8823 
    args = processReturn_args()
8824 
    args.read(iprot)
8825 
    iprot.readMessageEnd()
8826 
    result = processReturn_result()
8827 
    try:
8828 
      self._handler.processReturn(args.returnOrderId)
8829 
    except TransactionServiceException, ex:
8830 
      result.ex = ex
8831 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8832 
    result.write(oprot)
8833 
    oprot.writeMessageEnd()
8834 
    oprot.trans.flush()
8835 
 
3451 chandransh 8836 
  def process_updateWeight(self, seqid, iprot, oprot):
8837 
    args = updateWeight_args()
8838 
    args.read(iprot)
8839 
    iprot.readMessageEnd()
8840 
    result = updateWeight_result()
8841 
    try:
8842 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8843 
    except TransactionServiceException, ex:
8844 
      result.ex = ex
8845 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8846 
    result.write(oprot)
8847 
    oprot.writeMessageEnd()
8848 
    oprot.trans.flush()
2819 chandransh 8849 
 
3469 chandransh 8850 
  def process_changeItem(self, seqid, iprot, oprot):
8851 
    args = changeItem_args()
8852 
    args.read(iprot)
8853 
    iprot.readMessageEnd()
8854 
    result = changeItem_result()
8855 
    try:
8856 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8857 
    except TransactionServiceException, ex:
8858 
      result.ex = ex
8859 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8860 
    result.write(oprot)
8861 
    oprot.writeMessageEnd()
8862 
    oprot.trans.flush()
3451 chandransh 8863 
 
3469 chandransh 8864 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8865 
    args = shiftToWarehouse_args()
8866 
    args.read(iprot)
8867 
    iprot.readMessageEnd()
8868 
    result = shiftToWarehouse_result()
8869 
    try:
8870 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8871 
    except TransactionServiceException, ex:
8872 
      result.ex = ex
8873 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8874 
    result.write(oprot)
8875 
    oprot.writeMessageEnd()
8876 
    oprot.trans.flush()
8877 
 
3553 chandransh 8878 
  def process_addDelayReason(self, seqid, iprot, oprot):
8879 
    args = addDelayReason_args()
8880 
    args.read(iprot)
8881 
    iprot.readMessageEnd()
8882 
    result = addDelayReason_result()
8883 
    try:
4647 rajveer 8884 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8885 
    except TransactionServiceException, ex:
8886 
      result.ex = ex
8887 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8888 
    result.write(oprot)
8889 
    oprot.writeMessageEnd()
8890 
    oprot.trans.flush()
3469 chandransh 8891 
 
3956 chandransh 8892 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8893 
    args = reconcileCodCollection_args()
8894 
    args.read(iprot)
8895 
    iprot.readMessageEnd()
8896 
    result = reconcileCodCollection_result()
8897 
    try:
8898 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8899 
    except TransactionServiceException, ex:
8900 
      result.ex = ex
8901 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8902 
    result.write(oprot)
8903 
    oprot.writeMessageEnd()
8904 
    oprot.trans.flush()
3553 chandransh 8905 
 
4008 mandeep.dh 8906 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8907 
    args = getTransactionsRequiringExtraProcessing_args()
8908 
    args.read(iprot)
8909 
    iprot.readMessageEnd()
8910 
    result = getTransactionsRequiringExtraProcessing_result()
8911 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8912 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8913 
    result.write(oprot)
8914 
    oprot.writeMessageEnd()
8915 
    oprot.trans.flush()
3956 chandransh 8916 
 
4008 mandeep.dh 8917 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8918 
    args = markTransactionAsProcessed_args()
8919 
    args.read(iprot)
8920 
    iprot.readMessageEnd()
8921 
    result = markTransactionAsProcessed_result()
8922 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8923 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8924 
    result.write(oprot)
8925 
    oprot.writeMessageEnd()
8926 
    oprot.trans.flush()
8927 
 
4018 chandransh 8928 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8929 
    args = getItemWiseRiskyOrdersCount_args()
8930 
    args.read(iprot)
8931 
    iprot.readMessageEnd()
8932 
    result = getItemWiseRiskyOrdersCount_result()
8933 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8934 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8935 
    result.write(oprot)
8936 
    oprot.writeMessageEnd()
8937 
    oprot.trans.flush()
4008 mandeep.dh 8938 
 
4295 varun.gupt 8939 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8940 
    args = getOrdersForItemIds_args()
8941 
    args.read(iprot)
8942 
    iprot.readMessageEnd()
8943 
    result = getOrdersForItemIds_result()
8944 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8945 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8946 
    result.write(oprot)
8947 
    oprot.writeMessageEnd()
8948 
    oprot.trans.flush()
8949 
 
4247 rajveer 8950 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8951 
    args = markOrderCancellationRequestReceived_args()
8952 
    args.read(iprot)
8953 
    iprot.readMessageEnd()
8954 
    result = markOrderCancellationRequestReceived_result()
8955 
    try:
8956 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8957 
    except TransactionServiceException, ex:
8958 
      result.ex = ex
8959 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8960 
    result.write(oprot)
8961 
    oprot.writeMessageEnd()
8962 
    oprot.trans.flush()
4018 chandransh 8963 
 
4247 rajveer 8964 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8965 
    args = markOrderCancellationRequestConfirmed_args()
8966 
    args.read(iprot)
8967 
    iprot.readMessageEnd()
8968 
    result = markOrderCancellationRequestConfirmed_result()
8969 
    try:
8970 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8971 
    except TransactionServiceException, ex:
8972 
      result.ex = ex
8973 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8974 
    result.write(oprot)
8975 
    oprot.writeMessageEnd()
8976 
    oprot.trans.flush()
8977 
 
8978 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8979 
    args = markOrderCancellationRequestDenied_args()
8980 
    args.read(iprot)
8981 
    iprot.readMessageEnd()
8982 
    result = markOrderCancellationRequestDenied_result()
8983 
    try:
8984 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8985 
    except TransactionServiceException, ex:
8986 
      result.ex = ex
8987 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8988 
    result.write(oprot)
8989 
    oprot.writeMessageEnd()
8990 
    oprot.trans.flush()
8991 
 
4258 rajveer 8992 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8993 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8994 
    args.read(iprot)
8995 
    iprot.readMessageEnd()
4258 rajveer 8996 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8997 
    try:
4258 rajveer 8998 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8999 
    except TransactionServiceException, ex:
9000 
      result.ex = ex
4258 rajveer 9001 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 9002 
    result.write(oprot)
9003 
    oprot.writeMessageEnd()
9004 
    oprot.trans.flush()
9005 
 
4259 anupam.sin 9006 
  def process_refundTransaction(self, seqid, iprot, oprot):
9007 
    args = refundTransaction_args()
9008 
    args.read(iprot)
9009 
    iprot.readMessageEnd()
9010 
    result = refundTransaction_result()
9011 
    try:
9012 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
9013 
    except TransactionServiceException, ex:
9014 
      result.ex = ex
9015 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
9016 
    result.write(oprot)
9017 
    oprot.writeMessageEnd()
9018 
    oprot.trans.flush()
4247 rajveer 9019 
 
4324 mandeep.dh 9020 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
9021 
    args = updateShipmentAddress_args()
9022 
    args.read(iprot)
9023 
    iprot.readMessageEnd()
9024 
    result = updateShipmentAddress_result()
9025 
    try:
9026 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
9027 
    except TransactionServiceException, ex:
9028 
      result.ex = ex
9029 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
9030 
    result.write(oprot)
9031 
    oprot.writeMessageEnd()
9032 
    oprot.trans.flush()
9033 
 
4285 rajveer 9034 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
9035 
    args = acceptOrdersForItemId_args()
9036 
    args.read(iprot)
9037 
    iprot.readMessageEnd()
9038 
    result = acceptOrdersForItemId_result()
9039 
    try:
9040 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
9041 
    except TransactionServiceException, ex:
9042 
      result.ex = ex
9043 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
9044 
    result.write(oprot)
9045 
    oprot.writeMessageEnd()
9046 
    oprot.trans.flush()
4259 anupam.sin 9047 
 
4303 rajveer 9048 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
9049 
    args = markOrdersAsPORaised_args()
9050 
    args.read(iprot)
9051 
    iprot.readMessageEnd()
9052 
    result = markOrdersAsPORaised_result()
9053 
    try:
4369 rajveer 9054 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 9055 
    except TransactionServiceException, ex:
9056 
      result.ex = ex
9057 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
9058 
    result.write(oprot)
9059 
    oprot.writeMessageEnd()
9060 
    oprot.trans.flush()
4285 rajveer 9061 
 
4303 rajveer 9062 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
9063 
    args = markOrdersAsReversalInitiated_args()
9064 
    args.read(iprot)
9065 
    iprot.readMessageEnd()
9066 
    result = markOrdersAsReversalInitiated_result()
9067 
    try:
4369 rajveer 9068 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 9069 
    except TransactionServiceException, ex:
9070 
      result.ex = ex
9071 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
9072 
    result.write(oprot)
9073 
    oprot.writeMessageEnd()
9074 
    oprot.trans.flush()
9075 
 
9076 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
9077 
    args = markOrdersAsNotAvailabke_args()
9078 
    args.read(iprot)
9079 
    iprot.readMessageEnd()
9080 
    result = markOrdersAsNotAvailabke_result()
9081 
    try:
4369 rajveer 9082 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 9083 
    except TransactionServiceException, ex:
9084 
      result.ex = ex
9085 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
9086 
    result.write(oprot)
9087 
    oprot.writeMessageEnd()
9088 
    oprot.trans.flush()
9089 
 
4369 rajveer 9090 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
9091 
    args = markOrdersAsTimeout_args()
9092 
    args.read(iprot)
9093 
    iprot.readMessageEnd()
9094 
    result = markOrdersAsTimeout_result()
9095 
    try:
9096 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
9097 
    except TransactionServiceException, ex:
9098 
      result.ex = ex
9099 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
9100 
    result.write(oprot)
9101 
    oprot.writeMessageEnd()
9102 
    oprot.trans.flush()
4303 rajveer 9103 
 
4662 rajveer 9104 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
9105 
    args = markOrderAsLostInTransit_args()
9106 
    args.read(iprot)
9107 
    iprot.readMessageEnd()
9108 
    result = markOrderAsLostInTransit_result()
9109 
    try:
9110 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
9111 
    except TransactionServiceException, ex:
9112 
      result.ex = ex
9113 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
9114 
    result.write(oprot)
9115 
    oprot.writeMessageEnd()
9116 
    oprot.trans.flush()
9117 
 
4386 anupam.sin 9118 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
9119 
    args = getOrderForAwb_args()
9120 
    args.read(iprot)
9121 
    iprot.readMessageEnd()
9122 
    result = getOrderForAwb_result()
9123 
    try:
9124 
      result.success = self._handler.getOrderForAwb(args.awb)
9125 
    except TransactionServiceException, ex:
9126 
      result.ex = ex
9127 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
9128 
    result.write(oprot)
9129 
    oprot.writeMessageEnd()
9130 
    oprot.trans.flush()
4369 rajveer 9131 
 
4506 phani.kuma 9132 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
9133 
    args = getOrdersForProviderForStatus_args()
9134 
    args.read(iprot)
9135 
    iprot.readMessageEnd()
9136 
    result = getOrdersForProviderForStatus_result()
9137 
    try:
4910 phani.kuma 9138 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 9139 
    except TransactionServiceException, ex:
9140 
      result.ex = ex
9141 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
9142 
    result.write(oprot)
9143 
    oprot.writeMessageEnd()
9144 
    oprot.trans.flush()
4386 anupam.sin 9145 
 
4600 varun.gupt 9146 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
9147 
    args = getBilledOrdersForVendor_args()
9148 
    args.read(iprot)
9149 
    iprot.readMessageEnd()
9150 
    result = getBilledOrdersForVendor_result()
9151 
    try:
9152 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
9153 
    except TransactionServiceException, ex:
9154 
      result.ex = ex
9155 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
9156 
    result.write(oprot)
9157 
    oprot.writeMessageEnd()
9158 
    oprot.trans.flush()
4506 phani.kuma 9159 
 
4607 rajveer 9160 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
9161 
    args = getSlippedSippingDateOrders_args()
9162 
    args.read(iprot)
9163 
    iprot.readMessageEnd()
9164 
    result = getSlippedSippingDateOrders_result()
9165 
    try:
9166 
      result.success = self._handler.getSlippedSippingDateOrders()
9167 
    except TransactionServiceException, ex:
9168 
      result.ex = ex
9169 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
9170 
    result.write(oprot)
9171 
    oprot.writeMessageEnd()
9172 
    oprot.trans.flush()
9173 
 
4709 rajveer 9174 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
9175 
    args = getCancelledOrders_args()
9176 
    args.read(iprot)
9177 
    iprot.readMessageEnd()
9178 
    result = getCancelledOrders_result()
9179 
    try:
9180 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
9181 
    except TransactionServiceException, ex:
9182 
      result.ex = ex
9183 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
9184 
    result.write(oprot)
9185 
    oprot.writeMessageEnd()
9186 
    oprot.trans.flush()
9187 
 
4600 varun.gupt 9188 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
9189 
    args = saveBluedartSettlements_args()
9190 
    args.read(iprot)
9191 
    iprot.readMessageEnd()
9192 
    result = saveBluedartSettlements_result()
9193 
    try:
9194 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
9195 
    except TransactionServiceException, ex:
9196 
      result.ex = ex
9197 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
9198 
    result.write(oprot)
9199 
    oprot.writeMessageEnd()
9200 
    oprot.trans.flush()
9201 
 
9202 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
9203 
    args = savePaymentSettlements_args()
9204 
    args.read(iprot)
9205 
    iprot.readMessageEnd()
9206 
    result = savePaymentSettlements_result()
9207 
    try:
4905 varun.gupt 9208 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 9209 
    except TransactionServiceException, ex:
9210 
      result.ex = ex
9211 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
9212 
    result.write(oprot)
9213 
    oprot.writeMessageEnd()
9214 
    oprot.trans.flush()
9215 
 
9216 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
9217 
    args = saveEBSSettlementSummary_args()
9218 
    args.read(iprot)
9219 
    iprot.readMessageEnd()
9220 
    result = saveEBSSettlementSummary_result()
9221 
    try:
9222 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
9223 
    except TransactionServiceException, ex:
9224 
      result.ex = ex
9225 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
9226 
    result.write(oprot)
9227 
    oprot.writeMessageEnd()
9228 
    oprot.trans.flush()
9229 
 
5386 phani.kuma 9230 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
9231 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 9232 
    args.read(iprot)
9233 
    iprot.readMessageEnd()
5386 phani.kuma 9234 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 9235 
    try:
5386 phani.kuma 9236 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 9237 
    except TransactionServiceException, ex:
9238 
      result.ex = ex
5386 phani.kuma 9239 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 9240 
    result.write(oprot)
9241 
    oprot.writeMessageEnd()
9242 
    oprot.trans.flush()
9243 
 
5386 phani.kuma 9244 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
9245 
    args = getSettlementForCod_args()
9246 
    args.read(iprot)
9247 
    iprot.readMessageEnd()
9248 
    result = getSettlementForCod_result()
9249 
    try:
9250 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
9251 
    except TransactionServiceException, ex:
9252 
      result.ex = ex
9253 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
9254 
    result.write(oprot)
9255 
    oprot.writeMessageEnd()
9256 
    oprot.trans.flush()
9257 
 
4600 varun.gupt 9258 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
9259 
    args = getEBSSettlementSummaries_args()
9260 
    args.read(iprot)
9261 
    iprot.readMessageEnd()
9262 
    result = getEBSSettlementSummaries_result()
9263 
    try:
9264 
      result.success = self._handler.getEBSSettlementSummaries()
9265 
    except TransactionServiceException, ex:
9266 
      result.ex = ex
9267 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
9268 
    result.write(oprot)
9269 
    oprot.writeMessageEnd()
9270 
    oprot.trans.flush()
9271 
 
9272 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
9273 
    args = markEBSSettlementUploaded_args()
9274 
    args.read(iprot)
9275 
    iprot.readMessageEnd()
9276 
    result = markEBSSettlementUploaded_result()
9277 
    try:
9278 
      self._handler.markEBSSettlementUploaded(args.settlementId)
9279 
    except TransactionServiceException, ex:
9280 
      result.ex = ex
9281 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
9282 
    result.write(oprot)
9283 
    oprot.writeMessageEnd()
9284 
    oprot.trans.flush()
9285 
 
9286 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
9287 
    args = getEBSSettlementDate_args()
9288 
    args.read(iprot)
9289 
    iprot.readMessageEnd()
9290 
    result = getEBSSettlementDate_result()
9291 
    try:
9292 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
9293 
    except TransactionServiceException, ex:
9294 
      result.ex = ex
9295 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
9296 
    result.write(oprot)
9297 
    oprot.writeMessageEnd()
9298 
    oprot.trans.flush()
9299 
 
4715 varun.gupt 9300 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
9301 
    args = getSettlementsByDate_args()
9302 
    args.read(iprot)
9303 
    iprot.readMessageEnd()
9304 
    result = getSettlementsByDate_result()
9305 
    try:
9306 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
9307 
    except TransactionServiceException, ex:
9308 
      result.ex = ex
9309 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
9310 
    result.write(oprot)
9311 
    oprot.writeMessageEnd()
9312 
    oprot.trans.flush()
4600 varun.gupt 9313 
 
4715 varun.gupt 9314 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
9315 
    args = getReshippedOrderIds_args()
9316 
    args.read(iprot)
9317 
    iprot.readMessageEnd()
9318 
    result = getReshippedOrderIds_result()
9319 
    try:
9320 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
9321 
    except TransactionServiceException, ex:
9322 
      result.ex = ex
9323 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
9324 
    result.write(oprot)
9325 
    oprot.writeMessageEnd()
9326 
    oprot.trans.flush()
9327 
 
5481 phani.kuma 9328 
  def process_getBilledOrders(self, seqid, iprot, oprot):
9329 
    args = getBilledOrders_args()
4875 varun.gupt 9330 
    args.read(iprot)
9331 
    iprot.readMessageEnd()
5481 phani.kuma 9332 
    result = getBilledOrders_result()
4875 varun.gupt 9333 
    try:
5481 phani.kuma 9334 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 9335 
    except TransactionServiceException, ex:
9336 
      result.ex = ex
5481 phani.kuma 9337 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 9338 
    result.write(oprot)
9339 
    oprot.writeMessageEnd()
9340 
    oprot.trans.flush()
4757 mandeep.dh 9341 
 
5031 varun.gupt 9342 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
9343 
    args = getStatusDistributionOfOrders_args()
9344 
    args.read(iprot)
9345 
    iprot.readMessageEnd()
9346 
    result = getStatusDistributionOfOrders_result()
9347 
    try:
9348 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
9349 
    except TransactionServiceException, ex:
9350 
      result.ex = ex
9351 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
9352 
    result.write(oprot)
9353 
    oprot.writeMessageEnd()
9354 
    oprot.trans.flush()
4875 varun.gupt 9355 
 
5067 varun.gupt 9356 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
9357 
    args = getOrderIdsForStatus_args()
9358 
    args.read(iprot)
9359 
    iprot.readMessageEnd()
9360 
    result = getOrderIdsForStatus_result()
9361 
    try:
9362 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
9363 
    except TransactionServiceException, ex:
9364 
      result.ex = ex
9365 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
9366 
    result.write(oprot)
9367 
    oprot.writeMessageEnd()
9368 
    oprot.trans.flush()
5031 varun.gupt 9369 
 
5348 anupam.sin 9370 
  def process_updateCODAgent(self, seqid, iprot, oprot):
9371 
    args = updateCODAgent_args()
9372 
    args.read(iprot)
9373 
    iprot.readMessageEnd()
9374 
    result = updateCODAgent_result()
9375 
    try:
9376 
      self._handler.updateCODAgent(args.agent, args.orderId)
9377 
    except TransactionServiceException, ex:
9378 
      result.ex = ex
9379 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
9380 
    result.write(oprot)
9381 
    oprot.writeMessageEnd()
9382 
    oprot.trans.flush()
9383 
 
5099 varun.gupt 9384 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
9385 
    args = updateOrderAsPaidToVendor_args()
9386 
    args.read(iprot)
9387 
    iprot.readMessageEnd()
9388 
    result = updateOrderAsPaidToVendor_result()
9389 
    try:
9390 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
9391 
    except TransactionServiceException, ex:
9392 
      result.ex = ex
9393 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
9394 
    result.write(oprot)
9395 
    oprot.writeMessageEnd()
9396 
    oprot.trans.flush()
5067 varun.gupt 9397 
 
5386 phani.kuma 9398 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
9399 
    args = updateOrderOnlyAsPaidToVendor_args()
9400 
    args.read(iprot)
9401 
    iprot.readMessageEnd()
9402 
    result = updateOrderOnlyAsPaidToVendor_result()
9403 
    try:
9404 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
9405 
    except TransactionServiceException, ex:
9406 
      result.ex = ex
9407 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
9408 
    result.write(oprot)
9409 
    oprot.writeMessageEnd()
9410 
    oprot.trans.flush()
9411 
 
5208 varun.gupt 9412 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
9413 
    args = getRefundedOrdersMarkedPaid_args()
9414 
    args.read(iprot)
9415 
    iprot.readMessageEnd()
9416 
    result = getRefundedOrdersMarkedPaid_result()
9417 
    try:
9418 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
9419 
    except TransactionServiceException, ex:
9420 
      result.ex = ex
9421 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
9422 
    result.write(oprot)
9423 
    oprot.writeMessageEnd()
9424 
    oprot.trans.flush()
5099 varun.gupt 9425 
 
5447 anupam.sin 9426 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
9427 
    args = getAllVerificationAgents_args()
9428 
    args.read(iprot)
9429 
    iprot.readMessageEnd()
9430 
    result = getAllVerificationAgents_result()
9431 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
9432 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
9433 
    result.write(oprot)
9434 
    oprot.writeMessageEnd()
9435 
    oprot.trans.flush()
5208 varun.gupt 9436 
 
5527 anupam.sin 9437 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
9438 
    args = getAllAttributesForOrderId_args()
9439 
    args.read(iprot)
9440 
    iprot.readMessageEnd()
9441 
    result = getAllAttributesForOrderId_result()
9442 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
9443 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
9444 
    result.write(oprot)
9445 
    oprot.writeMessageEnd()
9446 
    oprot.trans.flush()
5447 anupam.sin 9447 
 
5676 rajveer 9448 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
9449 
    args = setOrderAttributes_args()
9450 
    args.read(iprot)
9451 
    iprot.readMessageEnd()
9452 
    result = setOrderAttributes_result()
9453 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
9454 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
9455 
    result.write(oprot)
9456 
    oprot.writeMessageEnd()
9457 
    oprot.trans.flush()
9458 
 
5527 anupam.sin 9459 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
9460 
    args = setOrderAttributeForTransaction_args()
9461 
    args.read(iprot)
9462 
    iprot.readMessageEnd()
9463 
    result = setOrderAttributeForTransaction_result()
9464 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
9465 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
9466 
    result.write(oprot)
9467 
    oprot.writeMessageEnd()
9468 
    oprot.trans.flush()
9469 
 
5553 rajveer 9470 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
9471 
    args = getReceivePendingOrders_args()
9472 
    args.read(iprot)
9473 
    iprot.readMessageEnd()
9474 
    result = getReceivePendingOrders_result()
9475 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
9476 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
9477 
    result.write(oprot)
9478 
    oprot.writeMessageEnd()
9479 
    oprot.trans.flush()
5527 anupam.sin 9480 
 
5553 rajveer 9481 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
9482 
    args = getReceivedAtStoreOrders_args()
9483 
    args.read(iprot)
9484 
    iprot.readMessageEnd()
9485 
    result = getReceivedAtStoreOrders_result()
9486 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
9487 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
9488 
    result.write(oprot)
9489 
    oprot.writeMessageEnd()
9490 
    oprot.trans.flush()
9491 
 
5713 rajveer 9492 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
9493 
    args = getOrdersCollectionAtStore_args()
9494 
    args.read(iprot)
9495 
    iprot.readMessageEnd()
9496 
    result = getOrdersCollectionAtStore_result()
9497 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
9498 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
9499 
    result.write(oprot)
9500 
    oprot.writeMessageEnd()
9501 
    oprot.trans.flush()
9502 
 
5833 rajveer 9503 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
9504 
    args = getOrderAttributeValue_args()
9505 
    args.read(iprot)
9506 
    iprot.readMessageEnd()
9507 
    result = getOrderAttributeValue_result()
9508 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
9509 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
9510 
    result.write(oprot)
9511 
    oprot.writeMessageEnd()
9512 
    oprot.trans.flush()
9513 
 
6019 rajveer 9514 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
9515 
    args = changeJacketNumber_args()
9516 
    args.read(iprot)
9517 
    iprot.readMessageEnd()
9518 
    result = changeJacketNumber_result()
9519 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
9520 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
9521 
    result.write(oprot)
9522 
    oprot.writeMessageEnd()
9523 
    oprot.trans.flush()
9524 
 
9525 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
9526 
    args = markOrderAsRtoInTransit_args()
9527 
    args.read(iprot)
9528 
    iprot.readMessageEnd()
9529 
    result = markOrderAsRtoInTransit_result()
9530 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
9531 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
9532 
    result.write(oprot)
9533 
    oprot.writeMessageEnd()
9534 
    oprot.trans.flush()
9535 
 
5593 mandeep.dh 9536 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
9537 
    args = acceptOrderForItem_args()
9538 
    args.read(iprot)
9539 
    iprot.readMessageEnd()
9540 
    result = acceptOrderForItem_result()
9541 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
9542 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
9543 
    result.write(oprot)
9544 
    oprot.writeMessageEnd()
9545 
    oprot.trans.flush()
5553 rajveer 9546 
 
6000 mandeep.dh 9547 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
9548 
    args = createRechargeOrder_args()
9549 
    args.read(iprot)
9550 
    iprot.readMessageEnd()
9551 
    result = createRechargeOrder_result()
9552 
    try:
9553 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
9554 
    except TransactionServiceException, ex:
9555 
      result.ex = ex
9556 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
9557 
    result.write(oprot)
9558 
    oprot.writeMessageEnd()
9559 
    oprot.trans.flush()
5593 mandeep.dh 9560 
 
6031 rajveer 9561 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
9562 
    args = getRechargeOrder_args()
9563 
    args.read(iprot)
9564 
    iprot.readMessageEnd()
9565 
    result = getRechargeOrder_result()
9566 
    try:
9567 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
9568 
    except TransactionServiceException, ex:
9569 
      result.ex = ex
9570 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
9571 
    result.write(oprot)
9572 
    oprot.writeMessageEnd()
9573 
    oprot.trans.flush()
9574 
 
9575 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
9576 
    args = getRechargeOrders_args()
9577 
    args.read(iprot)
9578 
    iprot.readMessageEnd()
9579 
    result = getRechargeOrders_result()
9580 
    result.success = self._handler.getRechargeOrders(args.userId)
9581 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
9582 
    result.write(oprot)
9583 
    oprot.writeMessageEnd()
9584 
    oprot.trans.flush()
9585 
 
6000 mandeep.dh 9586 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
9587 
    args = updateRechargeOrderStatus_args()
9588 
    args.read(iprot)
9589 
    iprot.readMessageEnd()
9590 
    result = updateRechargeOrderStatus_result()
9591 
    try:
6031 rajveer 9592 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 9593 
    except TransactionServiceException, ex:
9594 
      result.ex = ex
9595 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
9596 
    result.write(oprot)
9597 
    oprot.writeMessageEnd()
9598 
    oprot.trans.flush()
9599 
 
9600 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
9601 
    args = activateRechargeTxn_args()
9602 
    args.read(iprot)
9603 
    iprot.readMessageEnd()
9604 
    result = activateRechargeTxn_result()
9605 
    try:
6031 rajveer 9606 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 9607 
    except TransactionServiceException, ex:
9608 
      result.ex = ex
9609 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
9610 
    result.write(oprot)
9611 
    oprot.writeMessageEnd()
9612 
    oprot.trans.flush()
9613 
 
6031 rajveer 9614 
  def process_getUserWallet(self, seqid, iprot, oprot):
9615 
    args = getUserWallet_args()
6000 mandeep.dh 9616 
    args.read(iprot)
9617 
    iprot.readMessageEnd()
6031 rajveer 9618 
    result = getUserWallet_result()
9619 
    result.success = self._handler.getUserWallet(args.userId)
9620 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 9621 
    result.write(oprot)
9622 
    oprot.writeMessageEnd()
9623 
    oprot.trans.flush()
9624 
 
6031 rajveer 9625 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9626 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9627 
    args.read(iprot)
9628 
    iprot.readMessageEnd()
6031 rajveer 9629 
    result = getUserWalletHistory_result()
9630 
    result.success = self._handler.getUserWalletHistory(args.userId)
9631 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9632 
    result.write(oprot)
9633 
    oprot.writeMessageEnd()
9634 
    oprot.trans.flush()
9635 
 
6050 anupam.sin 9636 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9637 
    args = getRechargeOrdersForTransaction_args()
9638 
    args.read(iprot)
9639 
    iprot.readMessageEnd()
9640 
    result = getRechargeOrdersForTransaction_result()
9641 
    try:
9642 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9643 
    except TransactionServiceException, ex:
9644 
      result.ex = ex
9645 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9646 
    result.write(oprot)
9647 
    oprot.writeMessageEnd()
9648 
    oprot.trans.flush()
9649 
 
6048 rajveer 9650 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9651 
    args = getServiceProviders_args()
9652 
    args.read(iprot)
9653 
    iprot.readMessageEnd()
9654 
    result = getServiceProviders_result()
6206 rajveer 9655 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9656 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9657 
    result.write(oprot)
9658 
    oprot.writeMessageEnd()
9659 
    oprot.trans.flush()
6000 mandeep.dh 9660 
 
6048 rajveer 9661 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9662 
    args = getServiceProviderForDevice_args()
9663 
    args.read(iprot)
9664 
    iprot.readMessageEnd()
9665 
    result = getServiceProviderForDevice_result()
6049 rajveer 9666 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9667 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9668 
    result.write(oprot)
9669 
    oprot.writeMessageEnd()
9670 
    oprot.trans.flush()
9671 
 
6269 rajveer 9672 
  def process_validateRecharge(self, seqid, iprot, oprot):
9673 
    args = validateRecharge_args()
9674 
    args.read(iprot)
9675 
    iprot.readMessageEnd()
9676 
    result = validateRecharge_result()
6591 anupam.sin 9677 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9678 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9679 
    result.write(oprot)
9680 
    oprot.writeMessageEnd()
9681 
    oprot.trans.flush()
9682 
 
6094 rajveer 9683 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9684 
    args = getRechargeOrdersForDevice_args()
9685 
    args.read(iprot)
9686 
    iprot.readMessageEnd()
9687 
    result = getRechargeOrdersForDevice_result()
9688 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9689 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9690 
    result.write(oprot)
9691 
    oprot.writeMessageEnd()
9692 
    oprot.trans.flush()
6048 rajveer 9693 
 
6094 rajveer 9694 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9695 
    args = addAmountToWallet_args()
9696 
    args.read(iprot)
9697 
    iprot.readMessageEnd()
9698 
    result = addAmountToWallet_result()
9699 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9700 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9701 
    result.write(oprot)
9702 
    oprot.writeMessageEnd()
9703 
    oprot.trans.flush()
9704 
 
6188 rajveer 9705 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9706 
    args = getRechargeStatistics_args()
9707 
    args.read(iprot)
9708 
    iprot.readMessageEnd()
9709 
    result = getRechargeStatistics_result()
9710 
    result.success = self._handler.getRechargeStatistics()
9711 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9712 
    result.write(oprot)
9713 
    oprot.writeMessageEnd()
9714 
    oprot.trans.flush()
9715 
 
6154 rajveer 9716 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9717 
    args = getRechargeOrdersForStatus_args()
9718 
    args.read(iprot)
9719 
    iprot.readMessageEnd()
9720 
    result = getRechargeOrdersForStatus_result()
9721 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9722 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9723 
    result.write(oprot)
9724 
    oprot.writeMessageEnd()
9725 
    oprot.trans.flush()
6094 rajveer 9726 
 
6159 rajveer 9727 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9728 
    args = getPlansForOperator_args()
9729 
    args.read(iprot)
9730 
    iprot.readMessageEnd()
9731 
    result = getPlansForOperator_result()
9732 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9733 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9734 
    result.write(oprot)
9735 
    oprot.writeMessageEnd()
9736 
    oprot.trans.flush()
6154 rajveer 9737 
 
6289 anupam.sin 9738 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9739 
    args = getRechargeDenominations_args()
9740 
    args.read(iprot)
9741 
    iprot.readMessageEnd()
9742 
    result = getRechargeDenominations_result()
9743 
    try:
6307 anupam.sin 9744 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9745 
    except TransactionServiceException, ex:
9746 
      result.ex = ex
9747 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9748 
    result.write(oprot)
9749 
    oprot.writeMessageEnd()
9750 
    oprot.trans.flush()
6159 rajveer 9751 
 
6371 rajveer 9752 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9753 
    args = updateAvailabilityStatus_args()
9754 
    args.read(iprot)
9755 
    iprot.readMessageEnd()
9756 
    result = updateAvailabilityStatus_result()
9757 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9758 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9759 
    result.write(oprot)
9760 
    oprot.writeMessageEnd()
9761 
    oprot.trans.flush()
6289 anupam.sin 9762 
 
6389 rajveer 9763 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9764 
    args = getAvailableEmiSchemes_args()
9765 
    args.read(iprot)
9766 
    iprot.readMessageEnd()
9767 
    result = getAvailableEmiSchemes_result()
9768 
    result.success = self._handler.getAvailableEmiSchemes()
9769 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9770 
    result.write(oprot)
9771 
    oprot.writeMessageEnd()
9772 
    oprot.trans.flush()
6371 rajveer 9773 
 
6389 rajveer 9774 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9775 
    args = getMiscCharges_args()
9776 
    args.read(iprot)
9777 
    iprot.readMessageEnd()
9778 
    result = getMiscCharges_result()
9779 
    result.success = self._handler.getMiscCharges(args.transactionId)
9780 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9781 
    result.write(oprot)
9782 
    oprot.writeMessageEnd()
9783 
    oprot.trans.flush()
9784 
 
6507 anupam.sin 9785 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9786 
    args = refundRechargeOrder_args()
9787 
    args.read(iprot)
9788 
    iprot.readMessageEnd()
9789 
    result = refundRechargeOrder_result()
9790 
    try:
9791 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9792 
    except TransactionServiceException, ex:
9793 
      result.ex = ex
9794 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9795 
    result.write(oprot)
9796 
    oprot.writeMessageEnd()
9797 
    oprot.trans.flush()
6389 rajveer 9798 
 
6821 amar.kumar 9799 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9800 
    args = getPhysicalOrders_args()
9801 
    args.read(iprot)
9802 
    iprot.readMessageEnd()
9803 
    result = getPhysicalOrders_result()
9804 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9805 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9806 
    result.write(oprot)
9807 
    oprot.writeMessageEnd()
9808 
    oprot.trans.flush()
6507 anupam.sin 9809 
 
6906 rajveer 9810 
  def process_getDocument(self, seqid, iprot, oprot):
9811 
    args = getDocument_args()
9812 
    args.read(iprot)
9813 
    iprot.readMessageEnd()
9814 
    result = getDocument_result()
9815 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9816 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9817 
    result.write(oprot)
9818 
    oprot.writeMessageEnd()
9819 
    oprot.trans.flush()
6821 amar.kumar 9820 
 
6985 anupam.sin 9821 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9822 
    args = changeShippingAddress_args()
9823 
    args.read(iprot)
9824 
    iprot.readMessageEnd()
9825 
    result = changeShippingAddress_result()
9826 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9827 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9828 
    result.write(oprot)
9829 
    oprot.writeMessageEnd()
9830 
    oprot.trans.flush()
6906 rajveer 9831 
 
6988 rajveer 9832 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9833 
    args = retrieveInvoice_args()
9834 
    args.read(iprot)
9835 
    iprot.readMessageEnd()
9836 
    result = retrieveInvoice_result()
7075 rajveer 9837 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9838 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9839 
    result.write(oprot)
9840 
    oprot.writeMessageEnd()
9841 
    oprot.trans.flush()
6985 anupam.sin 9842 
 
7026 rajveer 9843 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9844 
    args = receiveUpdatesForRedExpress_args()
9845 
    args.read(iprot)
9846 
    iprot.readMessageEnd()
9847 
    result = receiveUpdatesForRedExpress_result()
9848 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9849 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9850 
    result.write(oprot)
9851 
    oprot.writeMessageEnd()
9852 
    oprot.trans.flush()
6988 rajveer 9853 
 
7073 anupam.sin 9854 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9855 
    args = createRechargeTransaction_args()
9856 
    args.read(iprot)
9857 
    iprot.readMessageEnd()
9858 
    result = createRechargeTransaction_result()
9859 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9860 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9861 
    result.write(oprot)
9862 
    oprot.writeMessageEnd()
9863 
    oprot.trans.flush()
7026 rajveer 9864 
 
7085 rajveer 9865 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9866 
    args = getRechargeTransactions_args()
9867 
    args.read(iprot)
9868 
    iprot.readMessageEnd()
9869 
    result = getRechargeTransactions_result()
9870 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9871 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9872 
    result.write(oprot)
9873 
    oprot.writeMessageEnd()
9874 
    oprot.trans.flush()
9875 
 
7151 amit.gupta 9876 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9877 
    args = getRechargeTrans_args()
9878 
    args.read(iprot)
9879 
    iprot.readMessageEnd()
9880 
    result = getRechargeTrans_result()
9881 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9882 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9883 
    result.write(oprot)
9884 
    oprot.writeMessageEnd()
9885 
    oprot.trans.flush()
9886 
 
7080 anupam.sin 9887 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9888 
    args = getRechargeTransaction_args()
9889 
    args.read(iprot)
9890 
    iprot.readMessageEnd()
9891 
    result = getRechargeTransaction_result()
9892 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9893 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9894 
    result.write(oprot)
9895 
    oprot.writeMessageEnd()
9896 
    oprot.trans.flush()
7073 anupam.sin 9897 
 
7080 anupam.sin 9898 
  def process_getFRCs(self, seqid, iprot, oprot):
9899 
    args = getFRCs_args()
9900 
    args.read(iprot)
9901 
    iprot.readMessageEnd()
9902 
    result = getFRCs_result()
9903 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9904 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9905 
    result.write(oprot)
9906 
    oprot.writeMessageEnd()
9907 
    oprot.trans.flush()
9908 
 
7096 anupam.sin 9909 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9910 
    args = getHotspotStore_args()
9911 
    args.read(iprot)
9912 
    iprot.readMessageEnd()
9913 
    result = getHotspotStore_result()
9914 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9915 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9916 
    result.write(oprot)
9917 
    oprot.writeMessageEnd()
9918 
    oprot.trans.flush()
7080 anupam.sin 9919 
 
7096 anupam.sin 9920 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9921 
    args = getTelecomCircle_args()
9922 
    args.read(iprot)
9923 
    iprot.readMessageEnd()
9924 
    result = getTelecomCircle_result()
9925 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9926 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9927 
    result.write(oprot)
9928 
    oprot.writeMessageEnd()
9929 
    oprot.trans.flush()
9930 
 
7109 anupam.sin 9931 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9932 
    args = retrieveHotspotRechargeInvoice_args()
9933 
    args.read(iprot)
9934 
    iprot.readMessageEnd()
9935 
    result = retrieveHotspotRechargeInvoice_result()
9936 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9937 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9938 
    result.write(oprot)
9939 
    oprot.writeMessageEnd()
9940 
    oprot.trans.flush()
7096 anupam.sin 9941 
 
7190 amar.kumar 9942 
  def process_splitFreebieOrder(self, seqid, iprot, oprot):
9943 
    args = splitFreebieOrder_args()
9944 
    args.read(iprot)
9945 
    iprot.readMessageEnd()
9946 
    result = splitFreebieOrder_result()
9947 
    result.success = self._handler.splitFreebieOrder(args.orderId, args.splitReason, args.shippingDate)
9948 
    oprot.writeMessageBegin("splitFreebieOrder", TMessageType.REPLY, seqid)
9949 
    result.write(oprot)
9950 
    oprot.writeMessageEnd()
9951 
    oprot.trans.flush()
9952 
 
7169 anupam.sin 9953 
  def process_getRechargeTransactionsByNumber(self, seqid, iprot, oprot):
9954 
    args = getRechargeTransactionsByNumber_args()
9955 
    args.read(iprot)
9956 
    iprot.readMessageEnd()
9957 
    result = getRechargeTransactionsByNumber_result()
7172 anupam.sin 9958 
    result.success = self._handler.getRechargeTransactionsByNumber(args.number, args.storeId)
7169 anupam.sin 9959 
    oprot.writeMessageBegin("getRechargeTransactionsByNumber", TMessageType.REPLY, seqid)
9960 
    result.write(oprot)
9961 
    oprot.writeMessageEnd()
9962 
    oprot.trans.flush()
7109 anupam.sin 9963 
 
7169 anupam.sin 9964 
  def process_updateHotspotStorePassword(self, seqid, iprot, oprot):
9965 
    args = updateHotspotStorePassword_args()
9966 
    args.read(iprot)
9967 
    iprot.readMessageEnd()
9968 
    result = updateHotspotStorePassword_result()
9969 
    result.success = self._handler.updateHotspotStorePassword(args.storeId, args.password)
9970 
    oprot.writeMessageBegin("updateHotspotStorePassword", TMessageType.REPLY, seqid)
9971 
    result.write(oprot)
9972 
    oprot.writeMessageEnd()
9973 
    oprot.trans.flush()
9974 
 
7285 rajveer 9975 
  def process_topupCompanyWallet(self, seqid, iprot, oprot):
9976 
    args = topupCompanyWallet_args()
7263 anupam.sin 9977 
    args.read(iprot)
9978 
    iprot.readMessageEnd()
7285 rajveer 9979 
    result = topupCompanyWallet_result()
9980 
    result.success = self._handler.topupCompanyWallet(args.companyId, args.amount)
9981 
    oprot.writeMessageBegin("topupCompanyWallet", TMessageType.REPLY, seqid)
7263 anupam.sin 9982 
    result.write(oprot)
9983 
    oprot.writeMessageEnd()
9984 
    oprot.trans.flush()
7169 anupam.sin 9985 
 
7285 rajveer 9986 
  def process_getWalletBalanceForCompany(self, seqid, iprot, oprot):
9987 
    args = getWalletBalanceForCompany_args()
7267 anupam.sin 9988 
    args.read(iprot)
9989 
    iprot.readMessageEnd()
7285 rajveer 9990 
    result = getWalletBalanceForCompany_result()
9991 
    result.success = self._handler.getWalletBalanceForCompany(args.companyId)
9992 
    oprot.writeMessageBegin("getWalletBalanceForCompany", TMessageType.REPLY, seqid)
7267 anupam.sin 9993 
    result.write(oprot)
9994 
    oprot.writeMessageEnd()
9995 
    oprot.trans.flush()
7263 anupam.sin 9996 
 
7363 rajveer 9997 
  def process_getSaholicRechargeBalance(self, seqid, iprot, oprot):
9998 
    args = getSaholicRechargeBalance_args()
9999 
    args.read(iprot)
10000 
    iprot.readMessageEnd()
10001 
    result = getSaholicRechargeBalance_result()
10002 
    result.success = self._handler.getSaholicRechargeBalance()
10003 
    oprot.writeMessageBegin("getSaholicRechargeBalance", TMessageType.REPLY, seqid)
10004 
    result.write(oprot)
10005 
    oprot.writeMessageEnd()
10006 
    oprot.trans.flush()
10007 
 
7285 rajveer 10008 
  def process_getSourceDetail(self, seqid, iprot, oprot):
10009 
    args = getSourceDetail_args()
7267 anupam.sin 10010 
    args.read(iprot)
10011 
    iprot.readMessageEnd()
7285 rajveer 10012 
    result = getSourceDetail_result()
10013 
    result.success = self._handler.getSourceDetail(args.source)
10014 
    oprot.writeMessageBegin("getSourceDetail", TMessageType.REPLY, seqid)
7267 anupam.sin 10015 
    result.write(oprot)
10016 
    oprot.writeMessageEnd()
10017 
    oprot.trans.flush()
10018 
 
7308 rajveer 10019 
  def process_getAllCircles(self, seqid, iprot, oprot):
10020 
    args = getAllCircles_args()
10021 
    args.read(iprot)
10022 
    iprot.readMessageEnd()
10023 
    result = getAllCircles_result()
10024 
    result.success = self._handler.getAllCircles()
10025 
    oprot.writeMessageBegin("getAllCircles", TMessageType.REPLY, seqid)
10026 
    result.write(oprot)
10027 
    oprot.writeMessageEnd()
10028 
    oprot.trans.flush()
7267 anupam.sin 10029 
 
7308 rajveer 10030 
  def process_deleteFrcs(self, seqid, iprot, oprot):
10031 
    args = deleteFrcs_args()
10032 
    args.read(iprot)
10033 
    iprot.readMessageEnd()
10034 
    result = deleteFrcs_result()
10035 
    result.success = self._handler.deleteFrcs(args.frcIdsToDelete)
10036 
    oprot.writeMessageBegin("deleteFrcs", TMessageType.REPLY, seqid)
10037 
    result.write(oprot)
10038 
    oprot.writeMessageEnd()
10039 
    oprot.trans.flush()
10040 
 
7311 kshitij.so 10041 
  def process_addAmazonOrder(self, seqid, iprot, oprot):
10042 
    args = addAmazonOrder_args()
10043 
    args.read(iprot)
10044 
    iprot.readMessageEnd()
10045 
    result = addAmazonOrder_result()
10046 
    self._handler.addAmazonOrder(args.amazonOrder)
10047 
    oprot.writeMessageBegin("addAmazonOrder", TMessageType.REPLY, seqid)
10048 
    result.write(oprot)
10049 
    oprot.writeMessageEnd()
10050 
    oprot.trans.flush()
7308 rajveer 10051 
 
7322 vikram.rag 10052 
  def process_updateAmazonOrderStatus(self, seqid, iprot, oprot):
10053 
    args = updateAmazonOrderStatus_args()
7311 kshitij.so 10054 
    args.read(iprot)
10055 
    iprot.readMessageEnd()
7322 vikram.rag 10056 
    result = updateAmazonOrderStatus_result()
10057 
    result.success = self._handler.updateAmazonOrderStatus(args.orderId, args.status)
10058 
    oprot.writeMessageBegin("updateAmazonOrderStatus", TMessageType.REPLY, seqid)
7311 kshitij.so 10059 
    result.write(oprot)
10060 
    oprot.writeMessageEnd()
10061 
    oprot.trans.flush()
10062 
 
10063 
  def process_getAmazonOrdersShipped(self, seqid, iprot, oprot):
10064 
    args = getAmazonOrdersShipped_args()
10065 
    args.read(iprot)
10066 
    iprot.readMessageEnd()
10067 
    result = getAmazonOrdersShipped_result()
10068 
    result.success = self._handler.getAmazonOrdersShipped(args.interval)
10069 
    oprot.writeMessageBegin("getAmazonOrdersShipped", TMessageType.REPLY, seqid)
10070 
    result.write(oprot)
10071 
    oprot.writeMessageEnd()
10072 
    oprot.trans.flush()
10073 
 
10074 
  def process_getAmazonOrdersCancelled(self, seqid, iprot, oprot):
10075 
    args = getAmazonOrdersCancelled_args()
10076 
    args.read(iprot)
10077 
    iprot.readMessageEnd()
10078 
    result = getAmazonOrdersCancelled_result()
10079 
    result.success = self._handler.getAmazonOrdersCancelled(args.interval)
10080 
    oprot.writeMessageBegin("getAmazonOrdersCancelled", TMessageType.REPLY, seqid)
10081 
    result.write(oprot)
10082 
    oprot.writeMessageEnd()
10083 
    oprot.trans.flush()
10084 
 
7322 vikram.rag 10085 
  def process_getAmazonOrder(self, seqid, iprot, oprot):
10086 
    args = getAmazonOrder_args()
10087 
    args.read(iprot)
10088 
    iprot.readMessageEnd()
10089 
    result = getAmazonOrder_result()
10090 
    result.success = self._handler.getAmazonOrder(args.orderId)
10091 
    oprot.writeMessageBegin("getAmazonOrder", TMessageType.REPLY, seqid)
10092 
    result.write(oprot)
10093 
    oprot.writeMessageEnd()
10094 
    oprot.trans.flush()
7311 kshitij.so 10095 
 
7343 anupam.sin 10096 
  def process_getOrdersForStore(self, seqid, iprot, oprot):
10097 
    args = getOrdersForStore_args()
10098 
    args.read(iprot)
10099 
    iprot.readMessageEnd()
10100 
    result = getOrdersForStore_result()
10101 
    result.success = self._handler.getOrdersForStore(args.id, args.storeId, args.startDate, args.endDate, args.statuses)
10102 
    oprot.writeMessageBegin("getOrdersForStore", TMessageType.REPLY, seqid)
10103 
    result.write(oprot)
10104 
    oprot.writeMessageEnd()
10105 
    oprot.trans.flush()
7322 vikram.rag 10106 
 
7343 anupam.sin 10107 
  def process_getStoreOrderAdvanceInvoice(self, seqid, iprot, oprot):
10108 
    args = getStoreOrderAdvanceInvoice_args()
10109 
    args.read(iprot)
10110 
    iprot.readMessageEnd()
10111 
    result = getStoreOrderAdvanceInvoice_result()
10112 
    result.success = self._handler.getStoreOrderAdvanceInvoice(args.orderId)
10113 
    oprot.writeMessageBegin("getStoreOrderAdvanceInvoice", TMessageType.REPLY, seqid)
10114 
    result.write(oprot)
10115 
    oprot.writeMessageEnd()
10116 
    oprot.trans.flush()
10117 
 
10118 
 
94 ashish 10119 
# HELPER FUNCTIONS AND STRUCTURES
10120 
 
10121 
class createTransaction_args:
10122 
  """
10123 
  Attributes:
10124 
   - transaction
10125 
  """
10126 
 
10127 
  thrift_spec = (
10128 
    None, # 0
10129 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
10130 
  )
10131 
 
10132 
  def __init__(self, transaction=None,):
10133 
    self.transaction = transaction
10134 
 
10135 
  def read(self, iprot):
10136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10138 
      return
10139 
    iprot.readStructBegin()
10140 
    while True:
10141 
      (fname, ftype, fid) = iprot.readFieldBegin()
10142 
      if ftype == TType.STOP:
10143 
        break
10144 
      if fid == 1:
10145 
        if ftype == TType.STRUCT:
10146 
          self.transaction = Transaction()
10147 
          self.transaction.read(iprot)
10148 
        else:
10149 
          iprot.skip(ftype)
10150 
      else:
10151 
        iprot.skip(ftype)
10152 
      iprot.readFieldEnd()
10153 
    iprot.readStructEnd()
10154 
 
10155 
  def write(self, oprot):
10156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10158 
      return
10159 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 10160 
    if self.transaction is not None:
94 ashish 10161 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
10162 
      self.transaction.write(oprot)
10163 
      oprot.writeFieldEnd()
10164 
    oprot.writeFieldStop()
10165 
    oprot.writeStructEnd()
10166 
 
3431 rajveer 10167 
  def validate(self):
10168 
    return
10169 
 
10170 
 
94 ashish 10171 
  def __repr__(self):
10172 
    L = ['%s=%r' % (key, value)
10173 
      for key, value in self.__dict__.iteritems()]
10174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10175 
 
10176 
  def __eq__(self, other):
10177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10178 
 
10179 
  def __ne__(self, other):
10180 
    return not (self == other)
10181 
 
10182 
class createTransaction_result:
10183 
  """
10184 
  Attributes:
132 ashish 10185 
   - success
94 ashish 10186 
   - ex
10187 
  """
10188 
 
10189 
  thrift_spec = (
132 ashish 10190 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10192 
  )
10193 
 
132 ashish 10194 
  def __init__(self, success=None, ex=None,):
10195 
    self.success = success
94 ashish 10196 
    self.ex = ex
10197 
 
10198 
  def read(self, iprot):
10199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10201 
      return
10202 
    iprot.readStructBegin()
10203 
    while True:
10204 
      (fname, ftype, fid) = iprot.readFieldBegin()
10205 
      if ftype == TType.STOP:
10206 
        break
132 ashish 10207 
      if fid == 0:
10208 
        if ftype == TType.I64:
10209 
          self.success = iprot.readI64();
10210 
        else:
10211 
          iprot.skip(ftype)
10212 
      elif fid == 1:
94 ashish 10213 
        if ftype == TType.STRUCT:
10214 
          self.ex = TransactionServiceException()
10215 
          self.ex.read(iprot)
10216 
        else:
10217 
          iprot.skip(ftype)
10218 
      else:
10219 
        iprot.skip(ftype)
10220 
      iprot.readFieldEnd()
10221 
    iprot.readStructEnd()
10222 
 
10223 
  def write(self, oprot):
10224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10226 
      return
10227 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 10228 
    if self.success is not None:
132 ashish 10229 
      oprot.writeFieldBegin('success', TType.I64, 0)
10230 
      oprot.writeI64(self.success)
10231 
      oprot.writeFieldEnd()
3431 rajveer 10232 
    if self.ex is not None:
94 ashish 10233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10234 
      self.ex.write(oprot)
10235 
      oprot.writeFieldEnd()
10236 
    oprot.writeFieldStop()
10237 
    oprot.writeStructEnd()
10238 
 
3431 rajveer 10239 
  def validate(self):
10240 
    return
10241 
 
10242 
 
94 ashish 10243 
  def __repr__(self):
10244 
    L = ['%s=%r' % (key, value)
10245 
      for key, value in self.__dict__.iteritems()]
10246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10247 
 
10248 
  def __eq__(self, other):
10249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10250 
 
10251 
  def __ne__(self, other):
10252 
    return not (self == other)
10253 
 
10254 
class getTransaction_args:
10255 
  """
10256 
  Attributes:
10257 
   - id
10258 
  """
10259 
 
10260 
  thrift_spec = (
10261 
    None, # 0
10262 
    (1, TType.I64, 'id', None, None, ), # 1
10263 
  )
10264 
 
10265 
  def __init__(self, id=None,):
10266 
    self.id = id
10267 
 
10268 
  def read(self, iprot):
10269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10271 
      return
10272 
    iprot.readStructBegin()
10273 
    while True:
10274 
      (fname, ftype, fid) = iprot.readFieldBegin()
10275 
      if ftype == TType.STOP:
10276 
        break
10277 
      if fid == 1:
10278 
        if ftype == TType.I64:
10279 
          self.id = iprot.readI64();
10280 
        else:
10281 
          iprot.skip(ftype)
10282 
      else:
10283 
        iprot.skip(ftype)
10284 
      iprot.readFieldEnd()
10285 
    iprot.readStructEnd()
10286 
 
10287 
  def write(self, oprot):
10288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10290 
      return
10291 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 10292 
    if self.id is not None:
94 ashish 10293 
      oprot.writeFieldBegin('id', TType.I64, 1)
10294 
      oprot.writeI64(self.id)
10295 
      oprot.writeFieldEnd()
10296 
    oprot.writeFieldStop()
10297 
    oprot.writeStructEnd()
10298 
 
3431 rajveer 10299 
  def validate(self):
10300 
    return
10301 
 
10302 
 
94 ashish 10303 
  def __repr__(self):
10304 
    L = ['%s=%r' % (key, value)
10305 
      for key, value in self.__dict__.iteritems()]
10306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10307 
 
10308 
  def __eq__(self, other):
10309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10310 
 
10311 
  def __ne__(self, other):
10312 
    return not (self == other)
10313 
 
10314 
class getTransaction_result:
10315 
  """
10316 
  Attributes:
10317 
   - success
10318 
   - ex
10319 
  """
10320 
 
10321 
  thrift_spec = (
10322 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
10323 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10324 
  )
10325 
 
10326 
  def __init__(self, success=None, ex=None,):
10327 
    self.success = success
10328 
    self.ex = ex
10329 
 
10330 
  def read(self, iprot):
10331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10333 
      return
10334 
    iprot.readStructBegin()
10335 
    while True:
10336 
      (fname, ftype, fid) = iprot.readFieldBegin()
10337 
      if ftype == TType.STOP:
10338 
        break
10339 
      if fid == 0:
10340 
        if ftype == TType.STRUCT:
10341 
          self.success = Transaction()
10342 
          self.success.read(iprot)
10343 
        else:
10344 
          iprot.skip(ftype)
10345 
      elif fid == 1:
10346 
        if ftype == TType.STRUCT:
10347 
          self.ex = TransactionServiceException()
10348 
          self.ex.read(iprot)
10349 
        else:
10350 
          iprot.skip(ftype)
10351 
      else:
10352 
        iprot.skip(ftype)
10353 
      iprot.readFieldEnd()
10354 
    iprot.readStructEnd()
10355 
 
10356 
  def write(self, oprot):
10357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10359 
      return
10360 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 10361 
    if self.success is not None:
94 ashish 10362 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10363 
      self.success.write(oprot)
10364 
      oprot.writeFieldEnd()
3431 rajveer 10365 
    if self.ex is not None:
94 ashish 10366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10367 
      self.ex.write(oprot)
10368 
      oprot.writeFieldEnd()
10369 
    oprot.writeFieldStop()
10370 
    oprot.writeStructEnd()
10371 
 
3431 rajveer 10372 
  def validate(self):
10373 
    return
10374 
 
10375 
 
94 ashish 10376 
  def __repr__(self):
10377 
    L = ['%s=%r' % (key, value)
10378 
      for key, value in self.__dict__.iteritems()]
10379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10380 
 
10381 
  def __eq__(self, other):
10382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10383 
 
10384 
  def __ne__(self, other):
10385 
    return not (self == other)
10386 
 
10387 
class getTransactionsForCustomer_args:
10388 
  """
10389 
  Attributes:
10390 
   - customerId
10391 
   - from_date
10392 
   - to_date
10393 
   - status
10394 
  """
10395 
 
10396 
  thrift_spec = (
10397 
    None, # 0
10398 
    (1, TType.I64, 'customerId', None, None, ), # 1
10399 
    (2, TType.I64, 'from_date', None, None, ), # 2
10400 
    (3, TType.I64, 'to_date', None, None, ), # 3
10401 
    (4, TType.I32, 'status', None, None, ), # 4
10402 
  )
10403 
 
10404 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
10405 
    self.customerId = customerId
10406 
    self.from_date = from_date
10407 
    self.to_date = to_date
10408 
    self.status = status
10409 
 
10410 
  def read(self, iprot):
10411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10413 
      return
10414 
    iprot.readStructBegin()
10415 
    while True:
10416 
      (fname, ftype, fid) = iprot.readFieldBegin()
10417 
      if ftype == TType.STOP:
10418 
        break
10419 
      if fid == 1:
10420 
        if ftype == TType.I64:
10421 
          self.customerId = iprot.readI64();
10422 
        else:
10423 
          iprot.skip(ftype)
10424 
      elif fid == 2:
10425 
        if ftype == TType.I64:
10426 
          self.from_date = iprot.readI64();
10427 
        else:
10428 
          iprot.skip(ftype)
10429 
      elif fid == 3:
10430 
        if ftype == TType.I64:
10431 
          self.to_date = iprot.readI64();
10432 
        else:
10433 
          iprot.skip(ftype)
10434 
      elif fid == 4:
10435 
        if ftype == TType.I32:
10436 
          self.status = iprot.readI32();
10437 
        else:
10438 
          iprot.skip(ftype)
10439 
      else:
10440 
        iprot.skip(ftype)
10441 
      iprot.readFieldEnd()
10442 
    iprot.readStructEnd()
10443 
 
10444 
  def write(self, oprot):
10445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10447 
      return
10448 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 10449 
    if self.customerId is not None:
94 ashish 10450 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10451 
      oprot.writeI64(self.customerId)
10452 
      oprot.writeFieldEnd()
3431 rajveer 10453 
    if self.from_date is not None:
94 ashish 10454 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10455 
      oprot.writeI64(self.from_date)
10456 
      oprot.writeFieldEnd()
3431 rajveer 10457 
    if self.to_date is not None:
94 ashish 10458 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10459 
      oprot.writeI64(self.to_date)
10460 
      oprot.writeFieldEnd()
3431 rajveer 10461 
    if self.status is not None:
94 ashish 10462 
      oprot.writeFieldBegin('status', TType.I32, 4)
10463 
      oprot.writeI32(self.status)
10464 
      oprot.writeFieldEnd()
10465 
    oprot.writeFieldStop()
10466 
    oprot.writeStructEnd()
10467 
 
3431 rajveer 10468 
  def validate(self):
10469 
    return
10470 
 
10471 
 
94 ashish 10472 
  def __repr__(self):
10473 
    L = ['%s=%r' % (key, value)
10474 
      for key, value in self.__dict__.iteritems()]
10475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10476 
 
10477 
  def __eq__(self, other):
10478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10479 
 
10480 
  def __ne__(self, other):
10481 
    return not (self == other)
10482 
 
10483 
class getTransactionsForCustomer_result:
10484 
  """
10485 
  Attributes:
10486 
   - success
10487 
   - ex
10488 
  """
10489 
 
10490 
  thrift_spec = (
10491 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10493 
  )
10494 
 
10495 
  def __init__(self, success=None, ex=None,):
10496 
    self.success = success
10497 
    self.ex = ex
10498 
 
10499 
  def read(self, iprot):
10500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10502 
      return
10503 
    iprot.readStructBegin()
10504 
    while True:
10505 
      (fname, ftype, fid) = iprot.readFieldBegin()
10506 
      if ftype == TType.STOP:
10507 
        break
10508 
      if fid == 0:
10509 
        if ftype == TType.LIST:
10510 
          self.success = []
6188 rajveer 10511 
          (_etype109, _size106) = iprot.readListBegin()
10512 
          for _i110 in xrange(_size106):
10513 
            _elem111 = Transaction()
10514 
            _elem111.read(iprot)
10515 
            self.success.append(_elem111)
94 ashish 10516 
          iprot.readListEnd()
10517 
        else:
10518 
          iprot.skip(ftype)
10519 
      elif fid == 1:
10520 
        if ftype == TType.STRUCT:
10521 
          self.ex = TransactionServiceException()
10522 
          self.ex.read(iprot)
10523 
        else:
10524 
          iprot.skip(ftype)
10525 
      else:
10526 
        iprot.skip(ftype)
10527 
      iprot.readFieldEnd()
10528 
    iprot.readStructEnd()
10529 
 
10530 
  def write(self, oprot):
10531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10533 
      return
10534 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 10535 
    if self.success is not None:
94 ashish 10536 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10537 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10538 
      for iter112 in self.success:
10539 
        iter112.write(oprot)
94 ashish 10540 
      oprot.writeListEnd()
10541 
      oprot.writeFieldEnd()
3431 rajveer 10542 
    if self.ex is not None:
94 ashish 10543 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10544 
      self.ex.write(oprot)
10545 
      oprot.writeFieldEnd()
10546 
    oprot.writeFieldStop()
10547 
    oprot.writeStructEnd()
10548 
 
3431 rajveer 10549 
  def validate(self):
10550 
    return
10551 
 
10552 
 
94 ashish 10553 
  def __repr__(self):
10554 
    L = ['%s=%r' % (key, value)
10555 
      for key, value in self.__dict__.iteritems()]
10556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10557 
 
10558 
  def __eq__(self, other):
10559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10560 
 
10561 
  def __ne__(self, other):
10562 
    return not (self == other)
10563 
 
132 ashish 10564 
class getTransactionsForShoppingCartId_args:
10565 
  """
10566 
  Attributes:
10567 
   - shoppingCartId
10568 
  """
10569 
 
10570 
  thrift_spec = (
10571 
    None, # 0
10572 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
10573 
  )
10574 
 
10575 
  def __init__(self, shoppingCartId=None,):
10576 
    self.shoppingCartId = shoppingCartId
10577 
 
10578 
  def read(self, iprot):
10579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10581 
      return
10582 
    iprot.readStructBegin()
10583 
    while True:
10584 
      (fname, ftype, fid) = iprot.readFieldBegin()
10585 
      if ftype == TType.STOP:
10586 
        break
10587 
      if fid == 1:
10588 
        if ftype == TType.I64:
10589 
          self.shoppingCartId = iprot.readI64();
10590 
        else:
10591 
          iprot.skip(ftype)
10592 
      else:
10593 
        iprot.skip(ftype)
10594 
      iprot.readFieldEnd()
10595 
    iprot.readStructEnd()
10596 
 
10597 
  def write(self, oprot):
10598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10600 
      return
10601 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 10602 
    if self.shoppingCartId is not None:
132 ashish 10603 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
10604 
      oprot.writeI64(self.shoppingCartId)
10605 
      oprot.writeFieldEnd()
10606 
    oprot.writeFieldStop()
10607 
    oprot.writeStructEnd()
10608 
 
3431 rajveer 10609 
  def validate(self):
10610 
    return
10611 
 
10612 
 
132 ashish 10613 
  def __repr__(self):
10614 
    L = ['%s=%r' % (key, value)
10615 
      for key, value in self.__dict__.iteritems()]
10616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10617 
 
10618 
  def __eq__(self, other):
10619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10620 
 
10621 
  def __ne__(self, other):
10622 
    return not (self == other)
10623 
 
10624 
class getTransactionsForShoppingCartId_result:
10625 
  """
10626 
  Attributes:
10627 
   - success
10628 
   - ex
10629 
  """
10630 
 
10631 
  thrift_spec = (
10632 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10633 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10634 
  )
10635 
 
10636 
  def __init__(self, success=None, ex=None,):
10637 
    self.success = success
10638 
    self.ex = ex
10639 
 
10640 
  def read(self, iprot):
10641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10643 
      return
10644 
    iprot.readStructBegin()
10645 
    while True:
10646 
      (fname, ftype, fid) = iprot.readFieldBegin()
10647 
      if ftype == TType.STOP:
10648 
        break
10649 
      if fid == 0:
10650 
        if ftype == TType.LIST:
10651 
          self.success = []
6188 rajveer 10652 
          (_etype116, _size113) = iprot.readListBegin()
10653 
          for _i117 in xrange(_size113):
10654 
            _elem118 = Transaction()
10655 
            _elem118.read(iprot)
10656 
            self.success.append(_elem118)
132 ashish 10657 
          iprot.readListEnd()
10658 
        else:
10659 
          iprot.skip(ftype)
10660 
      elif fid == 1:
10661 
        if ftype == TType.STRUCT:
10662 
          self.ex = TransactionServiceException()
10663 
          self.ex.read(iprot)
10664 
        else:
10665 
          iprot.skip(ftype)
10666 
      else:
10667 
        iprot.skip(ftype)
10668 
      iprot.readFieldEnd()
10669 
    iprot.readStructEnd()
10670 
 
10671 
  def write(self, oprot):
10672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10674 
      return
10675 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 10676 
    if self.success is not None:
132 ashish 10677 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10678 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10679 
      for iter119 in self.success:
10680 
        iter119.write(oprot)
132 ashish 10681 
      oprot.writeListEnd()
10682 
      oprot.writeFieldEnd()
3431 rajveer 10683 
    if self.ex is not None:
132 ashish 10684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10685 
      self.ex.write(oprot)
10686 
      oprot.writeFieldEnd()
10687 
    oprot.writeFieldStop()
10688 
    oprot.writeStructEnd()
10689 
 
3431 rajveer 10690 
  def validate(self):
10691 
    return
10692 
 
10693 
 
132 ashish 10694 
  def __repr__(self):
10695 
    L = ['%s=%r' % (key, value)
10696 
      for key, value in self.__dict__.iteritems()]
10697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10698 
 
10699 
  def __eq__(self, other):
10700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10701 
 
10702 
  def __ne__(self, other):
10703 
    return not (self == other)
10704 
 
94 ashish 10705 
class getTransactionStatus_args:
10706 
  """
10707 
  Attributes:
10708 
   - transactionId
10709 
  """
10710 
 
10711 
  thrift_spec = (
10712 
    None, # 0
10713 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10714 
  )
10715 
 
10716 
  def __init__(self, transactionId=None,):
10717 
    self.transactionId = transactionId
10718 
 
10719 
  def read(self, iprot):
10720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10722 
      return
10723 
    iprot.readStructBegin()
10724 
    while True:
10725 
      (fname, ftype, fid) = iprot.readFieldBegin()
10726 
      if ftype == TType.STOP:
10727 
        break
10728 
      if fid == 1:
10729 
        if ftype == TType.I64:
10730 
          self.transactionId = iprot.readI64();
10731 
        else:
10732 
          iprot.skip(ftype)
10733 
      else:
10734 
        iprot.skip(ftype)
10735 
      iprot.readFieldEnd()
10736 
    iprot.readStructEnd()
10737 
 
10738 
  def write(self, oprot):
10739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10741 
      return
10742 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 10743 
    if self.transactionId is not None:
94 ashish 10744 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10745 
      oprot.writeI64(self.transactionId)
10746 
      oprot.writeFieldEnd()
10747 
    oprot.writeFieldStop()
10748 
    oprot.writeStructEnd()
10749 
 
3431 rajveer 10750 
  def validate(self):
10751 
    return
10752 
 
10753 
 
94 ashish 10754 
  def __repr__(self):
10755 
    L = ['%s=%r' % (key, value)
10756 
      for key, value in self.__dict__.iteritems()]
10757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10758 
 
10759 
  def __eq__(self, other):
10760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10761 
 
10762 
  def __ne__(self, other):
10763 
    return not (self == other)
10764 
 
10765 
class getTransactionStatus_result:
10766 
  """
10767 
  Attributes:
10768 
   - success
10769 
   - ex
10770 
  """
10771 
 
10772 
  thrift_spec = (
10773 
    (0, TType.I32, 'success', None, None, ), # 0
10774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10775 
  )
10776 
 
10777 
  def __init__(self, success=None, ex=None,):
10778 
    self.success = success
10779 
    self.ex = ex
10780 
 
10781 
  def read(self, iprot):
10782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10784 
      return
10785 
    iprot.readStructBegin()
10786 
    while True:
10787 
      (fname, ftype, fid) = iprot.readFieldBegin()
10788 
      if ftype == TType.STOP:
10789 
        break
10790 
      if fid == 0:
10791 
        if ftype == TType.I32:
10792 
          self.success = iprot.readI32();
10793 
        else:
10794 
          iprot.skip(ftype)
10795 
      elif fid == 1:
10796 
        if ftype == TType.STRUCT:
10797 
          self.ex = TransactionServiceException()
10798 
          self.ex.read(iprot)
10799 
        else:
10800 
          iprot.skip(ftype)
10801 
      else:
10802 
        iprot.skip(ftype)
10803 
      iprot.readFieldEnd()
10804 
    iprot.readStructEnd()
10805 
 
10806 
  def write(self, oprot):
10807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10809 
      return
10810 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10811 
    if self.success is not None:
94 ashish 10812 
      oprot.writeFieldBegin('success', TType.I32, 0)
10813 
      oprot.writeI32(self.success)
10814 
      oprot.writeFieldEnd()
3431 rajveer 10815 
    if self.ex is not None:
94 ashish 10816 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10817 
      self.ex.write(oprot)
10818 
      oprot.writeFieldEnd()
10819 
    oprot.writeFieldStop()
10820 
    oprot.writeStructEnd()
10821 
 
3431 rajveer 10822 
  def validate(self):
10823 
    return
10824 
 
10825 
 
94 ashish 10826 
  def __repr__(self):
10827 
    L = ['%s=%r' % (key, value)
10828 
      for key, value in self.__dict__.iteritems()]
10829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10830 
 
10831 
  def __eq__(self, other):
10832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10833 
 
10834 
  def __ne__(self, other):
10835 
    return not (self == other)
10836 
 
10837 
class changeTransactionStatus_args:
10838 
  """
10839 
  Attributes:
10840 
   - transactionId
10841 
   - status
10842 
   - description
5527 anupam.sin 10843 
   - pickUp
10844 
   - orderType
7293 anupam.sin 10845 
   - source
94 ashish 10846 
  """
10847 
 
10848 
  thrift_spec = (
10849 
    None, # 0
10850 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10851 
    (2, TType.I32, 'status', None, None, ), # 2
10852 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10853 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10854 
    (5, TType.I32, 'orderType', None, None, ), # 5
7293 anupam.sin 10855 
    (6, TType.I32, 'source', None, None, ), # 6
94 ashish 10856 
  )
10857 
 
7293 anupam.sin 10858 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None, source=None,):
94 ashish 10859 
    self.transactionId = transactionId
10860 
    self.status = status
10861 
    self.description = description
5527 anupam.sin 10862 
    self.pickUp = pickUp
10863 
    self.orderType = orderType
7293 anupam.sin 10864 
    self.source = source
94 ashish 10865 
 
10866 
  def read(self, iprot):
10867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10869 
      return
10870 
    iprot.readStructBegin()
10871 
    while True:
10872 
      (fname, ftype, fid) = iprot.readFieldBegin()
10873 
      if ftype == TType.STOP:
10874 
        break
10875 
      if fid == 1:
10876 
        if ftype == TType.I64:
10877 
          self.transactionId = iprot.readI64();
10878 
        else:
10879 
          iprot.skip(ftype)
10880 
      elif fid == 2:
10881 
        if ftype == TType.I32:
10882 
          self.status = iprot.readI32();
10883 
        else:
10884 
          iprot.skip(ftype)
10885 
      elif fid == 3:
10886 
        if ftype == TType.STRING:
10887 
          self.description = iprot.readString();
10888 
        else:
10889 
          iprot.skip(ftype)
5387 rajveer 10890 
      elif fid == 4:
5527 anupam.sin 10891 
        if ftype == TType.I64:
10892 
          self.pickUp = iprot.readI64();
5387 rajveer 10893 
        else:
10894 
          iprot.skip(ftype)
5527 anupam.sin 10895 
      elif fid == 5:
10896 
        if ftype == TType.I32:
10897 
          self.orderType = iprot.readI32();
10898 
        else:
10899 
          iprot.skip(ftype)
7293 anupam.sin 10900 
      elif fid == 6:
10901 
        if ftype == TType.I32:
10902 
          self.source = iprot.readI32();
10903 
        else:
10904 
          iprot.skip(ftype)
94 ashish 10905 
      else:
10906 
        iprot.skip(ftype)
10907 
      iprot.readFieldEnd()
10908 
    iprot.readStructEnd()
10909 
 
10910 
  def write(self, oprot):
10911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10913 
      return
10914 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10915 
    if self.transactionId is not None:
94 ashish 10916 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10917 
      oprot.writeI64(self.transactionId)
10918 
      oprot.writeFieldEnd()
3431 rajveer 10919 
    if self.status is not None:
94 ashish 10920 
      oprot.writeFieldBegin('status', TType.I32, 2)
10921 
      oprot.writeI32(self.status)
10922 
      oprot.writeFieldEnd()
3431 rajveer 10923 
    if self.description is not None:
94 ashish 10924 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10925 
      oprot.writeString(self.description)
10926 
      oprot.writeFieldEnd()
5527 anupam.sin 10927 
    if self.pickUp is not None:
10928 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10929 
      oprot.writeI64(self.pickUp)
5387 rajveer 10930 
      oprot.writeFieldEnd()
5527 anupam.sin 10931 
    if self.orderType is not None:
10932 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10933 
      oprot.writeI32(self.orderType)
10934 
      oprot.writeFieldEnd()
7293 anupam.sin 10935 
    if self.source is not None:
10936 
      oprot.writeFieldBegin('source', TType.I32, 6)
10937 
      oprot.writeI32(self.source)
10938 
      oprot.writeFieldEnd()
94 ashish 10939 
    oprot.writeFieldStop()
10940 
    oprot.writeStructEnd()
10941 
 
3431 rajveer 10942 
  def validate(self):
10943 
    return
10944 
 
10945 
 
94 ashish 10946 
  def __repr__(self):
10947 
    L = ['%s=%r' % (key, value)
10948 
      for key, value in self.__dict__.iteritems()]
10949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10950 
 
10951 
  def __eq__(self, other):
10952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10953 
 
10954 
  def __ne__(self, other):
10955 
    return not (self == other)
10956 
 
10957 
class changeTransactionStatus_result:
10958 
  """
10959 
  Attributes:
10960 
   - success
10961 
   - ex
10962 
  """
10963 
 
10964 
  thrift_spec = (
10965 
    (0, TType.BOOL, 'success', None, None, ), # 0
10966 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10967 
  )
10968 
 
10969 
  def __init__(self, success=None, ex=None,):
10970 
    self.success = success
10971 
    self.ex = ex
10972 
 
10973 
  def read(self, iprot):
10974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10976 
      return
10977 
    iprot.readStructBegin()
10978 
    while True:
10979 
      (fname, ftype, fid) = iprot.readFieldBegin()
10980 
      if ftype == TType.STOP:
10981 
        break
10982 
      if fid == 0:
10983 
        if ftype == TType.BOOL:
10984 
          self.success = iprot.readBool();
10985 
        else:
10986 
          iprot.skip(ftype)
10987 
      elif fid == 1:
10988 
        if ftype == TType.STRUCT:
10989 
          self.ex = TransactionServiceException()
10990 
          self.ex.read(iprot)
10991 
        else:
10992 
          iprot.skip(ftype)
10993 
      else:
10994 
        iprot.skip(ftype)
10995 
      iprot.readFieldEnd()
10996 
    iprot.readStructEnd()
10997 
 
10998 
  def write(self, oprot):
10999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11001 
      return
11002 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 11003 
    if self.success is not None:
94 ashish 11004 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11005 
      oprot.writeBool(self.success)
11006 
      oprot.writeFieldEnd()
3431 rajveer 11007 
    if self.ex is not None:
94 ashish 11008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11009 
      self.ex.write(oprot)
11010 
      oprot.writeFieldEnd()
11011 
    oprot.writeFieldStop()
11012 
    oprot.writeStructEnd()
11013 
 
3431 rajveer 11014 
  def validate(self):
11015 
    return
11016 
 
11017 
 
94 ashish 11018 
  def __repr__(self):
11019 
    L = ['%s=%r' % (key, value)
11020 
      for key, value in self.__dict__.iteritems()]
11021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11022 
 
11023 
  def __eq__(self, other):
11024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11025 
 
11026 
  def __ne__(self, other):
11027 
    return not (self == other)
11028 
 
1398 varun.gupt 11029 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 11030 
  """
11031 
  Attributes:
11032 
   - transactionId
11033 
  """
11034 
 
11035 
  thrift_spec = (
11036 
    None, # 0
11037 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11038 
  )
11039 
 
11040 
  def __init__(self, transactionId=None,):
11041 
    self.transactionId = transactionId
11042 
 
11043 
  def read(self, iprot):
11044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11046 
      return
11047 
    iprot.readStructBegin()
11048 
    while True:
11049 
      (fname, ftype, fid) = iprot.readFieldBegin()
11050 
      if ftype == TType.STOP:
11051 
        break
11052 
      if fid == 1:
11053 
        if ftype == TType.I64:
11054 
          self.transactionId = iprot.readI64();
11055 
        else:
11056 
          iprot.skip(ftype)
11057 
      else:
11058 
        iprot.skip(ftype)
11059 
      iprot.readFieldEnd()
11060 
    iprot.readStructEnd()
11061 
 
11062 
  def write(self, oprot):
11063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11065 
      return
1398 varun.gupt 11066 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 11067 
    if self.transactionId is not None:
1382 varun.gupt 11068 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11069 
      oprot.writeI64(self.transactionId)
11070 
      oprot.writeFieldEnd()
11071 
    oprot.writeFieldStop()
11072 
    oprot.writeStructEnd()
11073 
 
3431 rajveer 11074 
  def validate(self):
11075 
    return
11076 
 
11077 
 
1382 varun.gupt 11078 
  def __repr__(self):
11079 
    L = ['%s=%r' % (key, value)
11080 
      for key, value in self.__dict__.iteritems()]
11081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11082 
 
11083 
  def __eq__(self, other):
11084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11085 
 
11086 
  def __ne__(self, other):
11087 
    return not (self == other)
11088 
 
1398 varun.gupt 11089 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 11090 
  """
11091 
  Attributes:
11092 
   - success
11093 
   - ex
11094 
  """
11095 
 
11096 
  thrift_spec = (
11097 
    (0, TType.BOOL, 'success', None, None, ), # 0
11098 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11099 
  )
11100 
 
11101 
  def __init__(self, success=None, ex=None,):
11102 
    self.success = success
11103 
    self.ex = ex
11104 
 
11105 
  def read(self, iprot):
11106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11108 
      return
11109 
    iprot.readStructBegin()
11110 
    while True:
11111 
      (fname, ftype, fid) = iprot.readFieldBegin()
11112 
      if ftype == TType.STOP:
11113 
        break
11114 
      if fid == 0:
11115 
        if ftype == TType.BOOL:
11116 
          self.success = iprot.readBool();
11117 
        else:
11118 
          iprot.skip(ftype)
11119 
      elif fid == 1:
11120 
        if ftype == TType.STRUCT:
11121 
          self.ex = TransactionServiceException()
11122 
          self.ex.read(iprot)
11123 
        else:
11124 
          iprot.skip(ftype)
11125 
      else:
11126 
        iprot.skip(ftype)
11127 
      iprot.readFieldEnd()
11128 
    iprot.readStructEnd()
11129 
 
11130 
  def write(self, oprot):
11131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11133 
      return
1398 varun.gupt 11134 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 11135 
    if self.success is not None:
1382 varun.gupt 11136 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11137 
      oprot.writeBool(self.success)
11138 
      oprot.writeFieldEnd()
3431 rajveer 11139 
    if self.ex is not None:
1382 varun.gupt 11140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11141 
      self.ex.write(oprot)
11142 
      oprot.writeFieldEnd()
11143 
    oprot.writeFieldStop()
11144 
    oprot.writeStructEnd()
11145 
 
3431 rajveer 11146 
  def validate(self):
11147 
    return
11148 
 
11149 
 
1382 varun.gupt 11150 
  def __repr__(self):
11151 
    L = ['%s=%r' % (key, value)
11152 
      for key, value in self.__dict__.iteritems()]
11153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11154 
 
11155 
  def __eq__(self, other):
11156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11157 
 
11158 
  def __ne__(self, other):
11159 
    return not (self == other)
11160 
 
483 rajveer 11161 
class getAllOrders_args:
94 ashish 11162 
  """
11163 
  Attributes:
4801 anupam.sin 11164 
   - statuses
483 rajveer 11165 
   - from_date
11166 
   - to_date
11167 
   - warehouse_id
94 ashish 11168 
  """
11169 
 
11170 
  thrift_spec = (
11171 
    None, # 0
4801 anupam.sin 11172 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 11173 
    (2, TType.I64, 'from_date', None, None, ), # 2
11174 
    (3, TType.I64, 'to_date', None, None, ), # 3
11175 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 11176 
  )
11177 
 
4801 anupam.sin 11178 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
11179 
    self.statuses = statuses
483 rajveer 11180 
    self.from_date = from_date
11181 
    self.to_date = to_date
11182 
    self.warehouse_id = warehouse_id
94 ashish 11183 
 
11184 
  def read(self, iprot):
11185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11187 
      return
11188 
    iprot.readStructBegin()
11189 
    while True:
11190 
      (fname, ftype, fid) = iprot.readFieldBegin()
11191 
      if ftype == TType.STOP:
11192 
        break
11193 
      if fid == 1:
4801 anupam.sin 11194 
        if ftype == TType.LIST:
11195 
          self.statuses = []
6188 rajveer 11196 
          (_etype123, _size120) = iprot.readListBegin()
11197 
          for _i124 in xrange(_size120):
11198 
            _elem125 = iprot.readI32();
11199 
            self.statuses.append(_elem125)
4801 anupam.sin 11200 
          iprot.readListEnd()
94 ashish 11201 
        else:
11202 
          iprot.skip(ftype)
483 rajveer 11203 
      elif fid == 2:
11204 
        if ftype == TType.I64:
11205 
          self.from_date = iprot.readI64();
94 ashish 11206 
        else:
11207 
          iprot.skip(ftype)
483 rajveer 11208 
      elif fid == 3:
11209 
        if ftype == TType.I64:
11210 
          self.to_date = iprot.readI64();
94 ashish 11211 
        else:
11212 
          iprot.skip(ftype)
483 rajveer 11213 
      elif fid == 4:
94 ashish 11214 
        if ftype == TType.I64:
483 rajveer 11215 
          self.warehouse_id = iprot.readI64();
94 ashish 11216 
        else:
11217 
          iprot.skip(ftype)
11218 
      else:
11219 
        iprot.skip(ftype)
11220 
      iprot.readFieldEnd()
11221 
    iprot.readStructEnd()
11222 
 
11223 
  def write(self, oprot):
11224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11226 
      return
483 rajveer 11227 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 11228 
    if self.statuses is not None:
11229 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11230 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11231 
      for iter126 in self.statuses:
11232 
        oprot.writeI32(iter126)
4801 anupam.sin 11233 
      oprot.writeListEnd()
94 ashish 11234 
      oprot.writeFieldEnd()
3431 rajveer 11235 
    if self.from_date is not None:
483 rajveer 11236 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11237 
      oprot.writeI64(self.from_date)
94 ashish 11238 
      oprot.writeFieldEnd()
3431 rajveer 11239 
    if self.to_date is not None:
483 rajveer 11240 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11241 
      oprot.writeI64(self.to_date)
94 ashish 11242 
      oprot.writeFieldEnd()
3431 rajveer 11243 
    if self.warehouse_id is not None:
483 rajveer 11244 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11245 
      oprot.writeI64(self.warehouse_id)
94 ashish 11246 
      oprot.writeFieldEnd()
11247 
    oprot.writeFieldStop()
11248 
    oprot.writeStructEnd()
11249 
 
3431 rajveer 11250 
  def validate(self):
11251 
    return
11252 
 
11253 
 
94 ashish 11254 
  def __repr__(self):
11255 
    L = ['%s=%r' % (key, value)
11256 
      for key, value in self.__dict__.iteritems()]
11257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11258 
 
11259 
  def __eq__(self, other):
11260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11261 
 
11262 
  def __ne__(self, other):
11263 
    return not (self == other)
11264 
 
483 rajveer 11265 
class getAllOrders_result:
94 ashish 11266 
  """
11267 
  Attributes:
11268 
   - success
11269 
   - ex
11270 
  """
11271 
 
11272 
  thrift_spec = (
483 rajveer 11273 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 11274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11275 
  )
11276 
 
11277 
  def __init__(self, success=None, ex=None,):
11278 
    self.success = success
11279 
    self.ex = ex
11280 
 
11281 
  def read(self, iprot):
11282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11284 
      return
11285 
    iprot.readStructBegin()
11286 
    while True:
11287 
      (fname, ftype, fid) = iprot.readFieldBegin()
11288 
      if ftype == TType.STOP:
11289 
        break
11290 
      if fid == 0:
483 rajveer 11291 
        if ftype == TType.LIST:
11292 
          self.success = []
6188 rajveer 11293 
          (_etype130, _size127) = iprot.readListBegin()
11294 
          for _i131 in xrange(_size127):
11295 
            _elem132 = Order()
11296 
            _elem132.read(iprot)
11297 
            self.success.append(_elem132)
483 rajveer 11298 
          iprot.readListEnd()
94 ashish 11299 
        else:
11300 
          iprot.skip(ftype)
11301 
      elif fid == 1:
11302 
        if ftype == TType.STRUCT:
11303 
          self.ex = TransactionServiceException()
11304 
          self.ex.read(iprot)
11305 
        else:
11306 
          iprot.skip(ftype)
11307 
      else:
11308 
        iprot.skip(ftype)
11309 
      iprot.readFieldEnd()
11310 
    iprot.readStructEnd()
11311 
 
11312 
  def write(self, oprot):
11313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11315 
      return
483 rajveer 11316 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 11317 
    if self.success is not None:
483 rajveer 11318 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11319 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11320 
      for iter133 in self.success:
11321 
        iter133.write(oprot)
483 rajveer 11322 
      oprot.writeListEnd()
94 ashish 11323 
      oprot.writeFieldEnd()
3431 rajveer 11324 
    if self.ex is not None:
94 ashish 11325 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11326 
      self.ex.write(oprot)
11327 
      oprot.writeFieldEnd()
11328 
    oprot.writeFieldStop()
11329 
    oprot.writeStructEnd()
11330 
 
3431 rajveer 11331 
  def validate(self):
11332 
    return
11333 
 
11334 
 
94 ashish 11335 
  def __repr__(self):
11336 
    L = ['%s=%r' % (key, value)
11337 
      for key, value in self.__dict__.iteritems()]
11338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11339 
 
11340 
  def __eq__(self, other):
11341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11342 
 
11343 
  def __ne__(self, other):
11344 
    return not (self == other)
11345 
 
4133 chandransh 11346 
class getOrdersInBatch_args:
11347 
  """
11348 
  Attributes:
11349 
   - statuses
11350 
   - offset
11351 
   - limit
11352 
   - warehouse_id
11353 
  """
11354 
 
11355 
  thrift_spec = (
11356 
    None, # 0
11357 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
11358 
    (2, TType.I64, 'offset', None, None, ), # 2
11359 
    (3, TType.I64, 'limit', None, None, ), # 3
11360 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11361 
  )
11362 
 
11363 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
11364 
    self.statuses = statuses
11365 
    self.offset = offset
11366 
    self.limit = limit
11367 
    self.warehouse_id = warehouse_id
11368 
 
11369 
  def read(self, iprot):
11370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11372 
      return
11373 
    iprot.readStructBegin()
11374 
    while True:
11375 
      (fname, ftype, fid) = iprot.readFieldBegin()
11376 
      if ftype == TType.STOP:
11377 
        break
11378 
      if fid == 1:
11379 
        if ftype == TType.LIST:
11380 
          self.statuses = []
6188 rajveer 11381 
          (_etype137, _size134) = iprot.readListBegin()
11382 
          for _i138 in xrange(_size134):
11383 
            _elem139 = iprot.readI32();
11384 
            self.statuses.append(_elem139)
4133 chandransh 11385 
          iprot.readListEnd()
11386 
        else:
11387 
          iprot.skip(ftype)
11388 
      elif fid == 2:
11389 
        if ftype == TType.I64:
11390 
          self.offset = iprot.readI64();
11391 
        else:
11392 
          iprot.skip(ftype)
11393 
      elif fid == 3:
11394 
        if ftype == TType.I64:
11395 
          self.limit = iprot.readI64();
11396 
        else:
11397 
          iprot.skip(ftype)
11398 
      elif fid == 4:
11399 
        if ftype == TType.I64:
11400 
          self.warehouse_id = iprot.readI64();
11401 
        else:
11402 
          iprot.skip(ftype)
11403 
      else:
11404 
        iprot.skip(ftype)
11405 
      iprot.readFieldEnd()
11406 
    iprot.readStructEnd()
11407 
 
11408 
  def write(self, oprot):
11409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11411 
      return
11412 
    oprot.writeStructBegin('getOrdersInBatch_args')
11413 
    if self.statuses is not None:
11414 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11415 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11416 
      for iter140 in self.statuses:
11417 
        oprot.writeI32(iter140)
4133 chandransh 11418 
      oprot.writeListEnd()
11419 
      oprot.writeFieldEnd()
11420 
    if self.offset is not None:
11421 
      oprot.writeFieldBegin('offset', TType.I64, 2)
11422 
      oprot.writeI64(self.offset)
11423 
      oprot.writeFieldEnd()
11424 
    if self.limit is not None:
11425 
      oprot.writeFieldBegin('limit', TType.I64, 3)
11426 
      oprot.writeI64(self.limit)
11427 
      oprot.writeFieldEnd()
11428 
    if self.warehouse_id is not None:
11429 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11430 
      oprot.writeI64(self.warehouse_id)
11431 
      oprot.writeFieldEnd()
11432 
    oprot.writeFieldStop()
11433 
    oprot.writeStructEnd()
11434 
 
11435 
  def validate(self):
11436 
    return
11437 
 
11438 
 
11439 
  def __repr__(self):
11440 
    L = ['%s=%r' % (key, value)
11441 
      for key, value in self.__dict__.iteritems()]
11442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11443 
 
11444 
  def __eq__(self, other):
11445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11446 
 
11447 
  def __ne__(self, other):
11448 
    return not (self == other)
11449 
 
11450 
class getOrdersInBatch_result:
11451 
  """
11452 
  Attributes:
11453 
   - success
11454 
   - ex
11455 
  """
11456 
 
11457 
  thrift_spec = (
11458 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11460 
  )
11461 
 
11462 
  def __init__(self, success=None, ex=None,):
11463 
    self.success = success
11464 
    self.ex = ex
11465 
 
11466 
  def read(self, iprot):
11467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11469 
      return
11470 
    iprot.readStructBegin()
11471 
    while True:
11472 
      (fname, ftype, fid) = iprot.readFieldBegin()
11473 
      if ftype == TType.STOP:
11474 
        break
11475 
      if fid == 0:
11476 
        if ftype == TType.LIST:
11477 
          self.success = []
6188 rajveer 11478 
          (_etype144, _size141) = iprot.readListBegin()
11479 
          for _i145 in xrange(_size141):
11480 
            _elem146 = Order()
11481 
            _elem146.read(iprot)
11482 
            self.success.append(_elem146)
4133 chandransh 11483 
          iprot.readListEnd()
11484 
        else:
11485 
          iprot.skip(ftype)
11486 
      elif fid == 1:
11487 
        if ftype == TType.STRUCT:
11488 
          self.ex = TransactionServiceException()
11489 
          self.ex.read(iprot)
11490 
        else:
11491 
          iprot.skip(ftype)
11492 
      else:
11493 
        iprot.skip(ftype)
11494 
      iprot.readFieldEnd()
11495 
    iprot.readStructEnd()
11496 
 
11497 
  def write(self, oprot):
11498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11500 
      return
11501 
    oprot.writeStructBegin('getOrdersInBatch_result')
11502 
    if self.success is not None:
11503 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11504 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11505 
      for iter147 in self.success:
11506 
        iter147.write(oprot)
4133 chandransh 11507 
      oprot.writeListEnd()
11508 
      oprot.writeFieldEnd()
11509 
    if self.ex is not None:
11510 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11511 
      self.ex.write(oprot)
11512 
      oprot.writeFieldEnd()
11513 
    oprot.writeFieldStop()
11514 
    oprot.writeStructEnd()
11515 
 
11516 
  def validate(self):
11517 
    return
11518 
 
11519 
 
11520 
  def __repr__(self):
11521 
    L = ['%s=%r' % (key, value)
11522 
      for key, value in self.__dict__.iteritems()]
11523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11524 
 
11525 
  def __eq__(self, other):
11526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11527 
 
11528 
  def __ne__(self, other):
11529 
    return not (self == other)
11530 
 
11531 
class getOrderCount_args:
11532 
  """
11533 
  Attributes:
11534 
   - statuses
11535 
   - warehouseId
11536 
  """
11537 
 
11538 
  thrift_spec = (
11539 
    None, # 0
11540 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
11541 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11542 
  )
11543 
 
11544 
  def __init__(self, statuses=None, warehouseId=None,):
11545 
    self.statuses = statuses
11546 
    self.warehouseId = warehouseId
11547 
 
11548 
  def read(self, iprot):
11549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11551 
      return
11552 
    iprot.readStructBegin()
11553 
    while True:
11554 
      (fname, ftype, fid) = iprot.readFieldBegin()
11555 
      if ftype == TType.STOP:
11556 
        break
11557 
      if fid == 1:
11558 
        if ftype == TType.LIST:
11559 
          self.statuses = []
6188 rajveer 11560 
          (_etype151, _size148) = iprot.readListBegin()
11561 
          for _i152 in xrange(_size148):
11562 
            _elem153 = iprot.readI32();
11563 
            self.statuses.append(_elem153)
4133 chandransh 11564 
          iprot.readListEnd()
11565 
        else:
11566 
          iprot.skip(ftype)
11567 
      elif fid == 2:
11568 
        if ftype == TType.I64:
11569 
          self.warehouseId = iprot.readI64();
11570 
        else:
11571 
          iprot.skip(ftype)
11572 
      else:
11573 
        iprot.skip(ftype)
11574 
      iprot.readFieldEnd()
11575 
    iprot.readStructEnd()
11576 
 
11577 
  def write(self, oprot):
11578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11580 
      return
11581 
    oprot.writeStructBegin('getOrderCount_args')
11582 
    if self.statuses is not None:
11583 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11584 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11585 
      for iter154 in self.statuses:
11586 
        oprot.writeI32(iter154)
4133 chandransh 11587 
      oprot.writeListEnd()
11588 
      oprot.writeFieldEnd()
11589 
    if self.warehouseId is not None:
11590 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11591 
      oprot.writeI64(self.warehouseId)
11592 
      oprot.writeFieldEnd()
11593 
    oprot.writeFieldStop()
11594 
    oprot.writeStructEnd()
11595 
 
11596 
  def validate(self):
11597 
    return
11598 
 
11599 
 
11600 
  def __repr__(self):
11601 
    L = ['%s=%r' % (key, value)
11602 
      for key, value in self.__dict__.iteritems()]
11603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11604 
 
11605 
  def __eq__(self, other):
11606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11607 
 
11608 
  def __ne__(self, other):
11609 
    return not (self == other)
11610 
 
11611 
class getOrderCount_result:
11612 
  """
11613 
  Attributes:
11614 
   - success
11615 
   - ex
11616 
  """
11617 
 
11618 
  thrift_spec = (
11619 
    (0, TType.I32, 'success', None, None, ), # 0
11620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11621 
  )
11622 
 
11623 
  def __init__(self, success=None, ex=None,):
11624 
    self.success = success
11625 
    self.ex = ex
11626 
 
11627 
  def read(self, iprot):
11628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11630 
      return
11631 
    iprot.readStructBegin()
11632 
    while True:
11633 
      (fname, ftype, fid) = iprot.readFieldBegin()
11634 
      if ftype == TType.STOP:
11635 
        break
11636 
      if fid == 0:
11637 
        if ftype == TType.I32:
11638 
          self.success = iprot.readI32();
11639 
        else:
11640 
          iprot.skip(ftype)
11641 
      elif fid == 1:
11642 
        if ftype == TType.STRUCT:
11643 
          self.ex = TransactionServiceException()
11644 
          self.ex.read(iprot)
11645 
        else:
11646 
          iprot.skip(ftype)
11647 
      else:
11648 
        iprot.skip(ftype)
11649 
      iprot.readFieldEnd()
11650 
    iprot.readStructEnd()
11651 
 
11652 
  def write(self, oprot):
11653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11655 
      return
11656 
    oprot.writeStructBegin('getOrderCount_result')
11657 
    if self.success is not None:
11658 
      oprot.writeFieldBegin('success', TType.I32, 0)
11659 
      oprot.writeI32(self.success)
11660 
      oprot.writeFieldEnd()
11661 
    if self.ex is not None:
11662 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11663 
      self.ex.write(oprot)
11664 
      oprot.writeFieldEnd()
11665 
    oprot.writeFieldStop()
11666 
    oprot.writeStructEnd()
11667 
 
11668 
  def validate(self):
11669 
    return
11670 
 
11671 
 
11672 
  def __repr__(self):
11673 
    L = ['%s=%r' % (key, value)
11674 
      for key, value in self.__dict__.iteritems()]
11675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11676 
 
11677 
  def __eq__(self, other):
11678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11679 
 
11680 
  def __ne__(self, other):
11681 
    return not (self == other)
11682 
 
999 varun.gupt 11683 
class getOrdersByBillingDate_args:
11684 
  """
11685 
  Attributes:
11686 
   - status
11687 
   - start_billing_date
11688 
   - end_billing_date
11689 
   - warehouse_id
11690 
  """
11691 
 
11692 
  thrift_spec = (
11693 
    None, # 0
11694 
    (1, TType.I32, 'status', None, None, ), # 1
11695 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
11696 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
11697 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11698 
  )
11699 
 
11700 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
11701 
    self.status = status
11702 
    self.start_billing_date = start_billing_date
11703 
    self.end_billing_date = end_billing_date
11704 
    self.warehouse_id = warehouse_id
11705 
 
11706 
  def read(self, iprot):
11707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11709 
      return
11710 
    iprot.readStructBegin()
11711 
    while True:
11712 
      (fname, ftype, fid) = iprot.readFieldBegin()
11713 
      if ftype == TType.STOP:
11714 
        break
11715 
      if fid == 1:
11716 
        if ftype == TType.I32:
11717 
          self.status = iprot.readI32();
11718 
        else:
11719 
          iprot.skip(ftype)
11720 
      elif fid == 2:
11721 
        if ftype == TType.I64:
11722 
          self.start_billing_date = iprot.readI64();
11723 
        else:
11724 
          iprot.skip(ftype)
11725 
      elif fid == 3:
11726 
        if ftype == TType.I64:
11727 
          self.end_billing_date = iprot.readI64();
11728 
        else:
11729 
          iprot.skip(ftype)
11730 
      elif fid == 4:
11731 
        if ftype == TType.I64:
11732 
          self.warehouse_id = iprot.readI64();
11733 
        else:
11734 
          iprot.skip(ftype)
11735 
      else:
11736 
        iprot.skip(ftype)
11737 
      iprot.readFieldEnd()
11738 
    iprot.readStructEnd()
11739 
 
11740 
  def write(self, oprot):
11741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11743 
      return
11744 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 11745 
    if self.status is not None:
999 varun.gupt 11746 
      oprot.writeFieldBegin('status', TType.I32, 1)
11747 
      oprot.writeI32(self.status)
11748 
      oprot.writeFieldEnd()
3431 rajveer 11749 
    if self.start_billing_date is not None:
999 varun.gupt 11750 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
11751 
      oprot.writeI64(self.start_billing_date)
11752 
      oprot.writeFieldEnd()
3431 rajveer 11753 
    if self.end_billing_date is not None:
999 varun.gupt 11754 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
11755 
      oprot.writeI64(self.end_billing_date)
11756 
      oprot.writeFieldEnd()
3431 rajveer 11757 
    if self.warehouse_id is not None:
999 varun.gupt 11758 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11759 
      oprot.writeI64(self.warehouse_id)
11760 
      oprot.writeFieldEnd()
11761 
    oprot.writeFieldStop()
11762 
    oprot.writeStructEnd()
11763 
 
3431 rajveer 11764 
  def validate(self):
11765 
    return
11766 
 
11767 
 
999 varun.gupt 11768 
  def __repr__(self):
11769 
    L = ['%s=%r' % (key, value)
11770 
      for key, value in self.__dict__.iteritems()]
11771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11772 
 
11773 
  def __eq__(self, other):
11774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11775 
 
11776 
  def __ne__(self, other):
11777 
    return not (self == other)
11778 
 
11779 
class getOrdersByBillingDate_result:
11780 
  """
11781 
  Attributes:
11782 
   - success
11783 
   - ex
11784 
  """
11785 
 
11786 
  thrift_spec = (
11787 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11788 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11789 
  )
11790 
 
11791 
  def __init__(self, success=None, ex=None,):
11792 
    self.success = success
11793 
    self.ex = ex
11794 
 
11795 
  def read(self, iprot):
11796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11798 
      return
11799 
    iprot.readStructBegin()
11800 
    while True:
11801 
      (fname, ftype, fid) = iprot.readFieldBegin()
11802 
      if ftype == TType.STOP:
11803 
        break
11804 
      if fid == 0:
11805 
        if ftype == TType.LIST:
11806 
          self.success = []
6188 rajveer 11807 
          (_etype158, _size155) = iprot.readListBegin()
11808 
          for _i159 in xrange(_size155):
11809 
            _elem160 = Order()
11810 
            _elem160.read(iprot)
11811 
            self.success.append(_elem160)
999 varun.gupt 11812 
          iprot.readListEnd()
11813 
        else:
11814 
          iprot.skip(ftype)
11815 
      elif fid == 1:
11816 
        if ftype == TType.STRUCT:
11817 
          self.ex = TransactionServiceException()
11818 
          self.ex.read(iprot)
11819 
        else:
11820 
          iprot.skip(ftype)
11821 
      else:
11822 
        iprot.skip(ftype)
11823 
      iprot.readFieldEnd()
11824 
    iprot.readStructEnd()
11825 
 
11826 
  def write(self, oprot):
11827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11829 
      return
11830 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11831 
    if self.success is not None:
999 varun.gupt 11832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11833 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11834 
      for iter161 in self.success:
11835 
        iter161.write(oprot)
999 varun.gupt 11836 
      oprot.writeListEnd()
11837 
      oprot.writeFieldEnd()
3431 rajveer 11838 
    if self.ex is not None:
999 varun.gupt 11839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11840 
      self.ex.write(oprot)
11841 
      oprot.writeFieldEnd()
11842 
    oprot.writeFieldStop()
11843 
    oprot.writeStructEnd()
11844 
 
3431 rajveer 11845 
  def validate(self):
11846 
    return
11847 
 
11848 
 
999 varun.gupt 11849 
  def __repr__(self):
11850 
    L = ['%s=%r' % (key, value)
11851 
      for key, value in self.__dict__.iteritems()]
11852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11853 
 
11854 
  def __eq__(self, other):
11855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11856 
 
11857 
  def __ne__(self, other):
11858 
    return not (self == other)
11859 
 
3427 chandransh 11860 
class getOrdersByShippingDate_args:
11861 
  """
11862 
  Attributes:
11863 
   - fromShippingDate
11864 
   - toShippingDate
11865 
   - providerId
11866 
   - warehouseId
3451 chandransh 11867 
   - cod
3427 chandransh 11868 
  """
11869 
 
11870 
  thrift_spec = (
11871 
    None, # 0
11872 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11873 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11874 
    (3, TType.I64, 'providerId', None, None, ), # 3
11875 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11876 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11877 
  )
11878 
 
3451 chandransh 11879 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11880 
    self.fromShippingDate = fromShippingDate
11881 
    self.toShippingDate = toShippingDate
11882 
    self.providerId = providerId
11883 
    self.warehouseId = warehouseId
3451 chandransh 11884 
    self.cod = cod
3427 chandransh 11885 
 
11886 
  def read(self, iprot):
11887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11889 
      return
11890 
    iprot.readStructBegin()
11891 
    while True:
11892 
      (fname, ftype, fid) = iprot.readFieldBegin()
11893 
      if ftype == TType.STOP:
11894 
        break
11895 
      if fid == 1:
11896 
        if ftype == TType.I64:
11897 
          self.fromShippingDate = iprot.readI64();
11898 
        else:
11899 
          iprot.skip(ftype)
11900 
      elif fid == 2:
11901 
        if ftype == TType.I64:
11902 
          self.toShippingDate = iprot.readI64();
11903 
        else:
11904 
          iprot.skip(ftype)
11905 
      elif fid == 3:
11906 
        if ftype == TType.I64:
11907 
          self.providerId = iprot.readI64();
11908 
        else:
11909 
          iprot.skip(ftype)
11910 
      elif fid == 4:
11911 
        if ftype == TType.I64:
11912 
          self.warehouseId = iprot.readI64();
11913 
        else:
11914 
          iprot.skip(ftype)
3451 chandransh 11915 
      elif fid == 5:
11916 
        if ftype == TType.BOOL:
11917 
          self.cod = iprot.readBool();
11918 
        else:
11919 
          iprot.skip(ftype)
3427 chandransh 11920 
      else:
11921 
        iprot.skip(ftype)
11922 
      iprot.readFieldEnd()
11923 
    iprot.readStructEnd()
11924 
 
11925 
  def write(self, oprot):
11926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11928 
      return
11929 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11930 
    if self.fromShippingDate is not None:
3427 chandransh 11931 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11932 
      oprot.writeI64(self.fromShippingDate)
11933 
      oprot.writeFieldEnd()
3431 rajveer 11934 
    if self.toShippingDate is not None:
3427 chandransh 11935 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11936 
      oprot.writeI64(self.toShippingDate)
11937 
      oprot.writeFieldEnd()
3431 rajveer 11938 
    if self.providerId is not None:
3427 chandransh 11939 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11940 
      oprot.writeI64(self.providerId)
11941 
      oprot.writeFieldEnd()
3431 rajveer 11942 
    if self.warehouseId is not None:
3427 chandransh 11943 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11944 
      oprot.writeI64(self.warehouseId)
11945 
      oprot.writeFieldEnd()
3451 chandransh 11946 
    if self.cod is not None:
11947 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11948 
      oprot.writeBool(self.cod)
11949 
      oprot.writeFieldEnd()
3427 chandransh 11950 
    oprot.writeFieldStop()
11951 
    oprot.writeStructEnd()
11952 
 
3431 rajveer 11953 
  def validate(self):
11954 
    return
11955 
 
11956 
 
3427 chandransh 11957 
  def __repr__(self):
11958 
    L = ['%s=%r' % (key, value)
11959 
      for key, value in self.__dict__.iteritems()]
11960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11961 
 
11962 
  def __eq__(self, other):
11963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11964 
 
11965 
  def __ne__(self, other):
11966 
    return not (self == other)
11967 
 
11968 
class getOrdersByShippingDate_result:
11969 
  """
11970 
  Attributes:
11971 
   - success
11972 
   - ex
11973 
  """
11974 
 
11975 
  thrift_spec = (
11976 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11977 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11978 
  )
11979 
 
11980 
  def __init__(self, success=None, ex=None,):
11981 
    self.success = success
11982 
    self.ex = ex
11983 
 
11984 
  def read(self, iprot):
11985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11987 
      return
11988 
    iprot.readStructBegin()
11989 
    while True:
11990 
      (fname, ftype, fid) = iprot.readFieldBegin()
11991 
      if ftype == TType.STOP:
11992 
        break
11993 
      if fid == 0:
11994 
        if ftype == TType.LIST:
11995 
          self.success = []
6188 rajveer 11996 
          (_etype165, _size162) = iprot.readListBegin()
11997 
          for _i166 in xrange(_size162):
11998 
            _elem167 = Order()
11999 
            _elem167.read(iprot)
12000 
            self.success.append(_elem167)
3427 chandransh 12001 
          iprot.readListEnd()
12002 
        else:
12003 
          iprot.skip(ftype)
12004 
      elif fid == 1:
12005 
        if ftype == TType.STRUCT:
12006 
          self.ex = TransactionServiceException()
12007 
          self.ex.read(iprot)
12008 
        else:
12009 
          iprot.skip(ftype)
12010 
      else:
12011 
        iprot.skip(ftype)
12012 
      iprot.readFieldEnd()
12013 
    iprot.readStructEnd()
12014 
 
12015 
  def write(self, oprot):
12016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12018 
      return
12019 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 12020 
    if self.success is not None:
3427 chandransh 12021 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12022 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12023 
      for iter168 in self.success:
12024 
        iter168.write(oprot)
3427 chandransh 12025 
      oprot.writeListEnd()
12026 
      oprot.writeFieldEnd()
3431 rajveer 12027 
    if self.ex is not None:
3427 chandransh 12028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12029 
      self.ex.write(oprot)
12030 
      oprot.writeFieldEnd()
12031 
    oprot.writeFieldStop()
12032 
    oprot.writeStructEnd()
12033 
 
3431 rajveer 12034 
  def validate(self):
12035 
    return
12036 
 
12037 
 
3427 chandransh 12038 
  def __repr__(self):
12039 
    L = ['%s=%r' % (key, value)
12040 
      for key, value in self.__dict__.iteritems()]
12041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12042 
 
12043 
  def __eq__(self, other):
12044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12045 
 
12046 
  def __ne__(self, other):
12047 
    return not (self == other)
12048 
 
1382 varun.gupt 12049 
class getReturnableOrdersForCustomer_args:
12050 
  """
12051 
  Attributes:
12052 
   - customer_id
12053 
   - limit
12054 
  """
12055 
 
12056 
  thrift_spec = (
12057 
    None, # 0
12058 
    (1, TType.I64, 'customer_id', None, None, ), # 1
12059 
    (2, TType.I64, 'limit', None, None, ), # 2
12060 
  )
12061 
 
12062 
  def __init__(self, customer_id=None, limit=None,):
12063 
    self.customer_id = customer_id
12064 
    self.limit = limit
12065 
 
12066 
  def read(self, iprot):
12067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12069 
      return
12070 
    iprot.readStructBegin()
12071 
    while True:
12072 
      (fname, ftype, fid) = iprot.readFieldBegin()
12073 
      if ftype == TType.STOP:
12074 
        break
12075 
      if fid == 1:
12076 
        if ftype == TType.I64:
12077 
          self.customer_id = iprot.readI64();
12078 
        else:
12079 
          iprot.skip(ftype)
12080 
      elif fid == 2:
12081 
        if ftype == TType.I64:
12082 
          self.limit = iprot.readI64();
12083 
        else:
12084 
          iprot.skip(ftype)
12085 
      else:
12086 
        iprot.skip(ftype)
12087 
      iprot.readFieldEnd()
12088 
    iprot.readStructEnd()
12089 
 
12090 
  def write(self, oprot):
12091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12093 
      return
12094 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 12095 
    if self.customer_id is not None:
1382 varun.gupt 12096 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
12097 
      oprot.writeI64(self.customer_id)
12098 
      oprot.writeFieldEnd()
3431 rajveer 12099 
    if self.limit is not None:
1382 varun.gupt 12100 
      oprot.writeFieldBegin('limit', TType.I64, 2)
12101 
      oprot.writeI64(self.limit)
12102 
      oprot.writeFieldEnd()
12103 
    oprot.writeFieldStop()
12104 
    oprot.writeStructEnd()
12105 
 
3431 rajveer 12106 
  def validate(self):
12107 
    return
12108 
 
12109 
 
1382 varun.gupt 12110 
  def __repr__(self):
12111 
    L = ['%s=%r' % (key, value)
12112 
      for key, value in self.__dict__.iteritems()]
12113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12114 
 
12115 
  def __eq__(self, other):
12116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12117 
 
12118 
  def __ne__(self, other):
12119 
    return not (self == other)
12120 
 
12121 
class getReturnableOrdersForCustomer_result:
12122 
  """
12123 
  Attributes:
12124 
   - success
12125 
   - ex
12126 
  """
12127 
 
12128 
  thrift_spec = (
12129 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12130 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12131 
  )
12132 
 
12133 
  def __init__(self, success=None, ex=None,):
12134 
    self.success = success
12135 
    self.ex = ex
12136 
 
12137 
  def read(self, iprot):
12138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12140 
      return
12141 
    iprot.readStructBegin()
12142 
    while True:
12143 
      (fname, ftype, fid) = iprot.readFieldBegin()
12144 
      if ftype == TType.STOP:
12145 
        break
12146 
      if fid == 0:
12147 
        if ftype == TType.LIST:
12148 
          self.success = []
6188 rajveer 12149 
          (_etype172, _size169) = iprot.readListBegin()
12150 
          for _i173 in xrange(_size169):
12151 
            _elem174 = iprot.readI64();
12152 
            self.success.append(_elem174)
1382 varun.gupt 12153 
          iprot.readListEnd()
12154 
        else:
12155 
          iprot.skip(ftype)
12156 
      elif fid == 1:
12157 
        if ftype == TType.STRUCT:
12158 
          self.ex = TransactionServiceException()
12159 
          self.ex.read(iprot)
12160 
        else:
12161 
          iprot.skip(ftype)
12162 
      else:
12163 
        iprot.skip(ftype)
12164 
      iprot.readFieldEnd()
12165 
    iprot.readStructEnd()
12166 
 
12167 
  def write(self, oprot):
12168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12170 
      return
12171 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 12172 
    if self.success is not None:
1382 varun.gupt 12173 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12174 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 12175 
      for iter175 in self.success:
12176 
        oprot.writeI64(iter175)
1382 varun.gupt 12177 
      oprot.writeListEnd()
12178 
      oprot.writeFieldEnd()
3431 rajveer 12179 
    if self.ex is not None:
1382 varun.gupt 12180 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12181 
      self.ex.write(oprot)
12182 
      oprot.writeFieldEnd()
12183 
    oprot.writeFieldStop()
12184 
    oprot.writeStructEnd()
12185 
 
3431 rajveer 12186 
  def validate(self):
12187 
    return
12188 
 
12189 
 
1382 varun.gupt 12190 
  def __repr__(self):
12191 
    L = ['%s=%r' % (key, value)
12192 
      for key, value in self.__dict__.iteritems()]
12193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12194 
 
12195 
  def __eq__(self, other):
12196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12197 
 
12198 
  def __ne__(self, other):
12199 
    return not (self == other)
12200 
 
12201 
class getCancellableOrdersForCustomer_args:
12202 
  """
12203 
  Attributes:
12204 
   - customer_id
12205 
   - limit
12206 
  """
12207 
 
12208 
  thrift_spec = (
12209 
    None, # 0
12210 
    (1, TType.I64, 'customer_id', None, None, ), # 1
12211 
    (2, TType.I64, 'limit', None, None, ), # 2
12212 
  )
12213 
 
12214 
  def __init__(self, customer_id=None, limit=None,):
12215 
    self.customer_id = customer_id
12216 
    self.limit = limit
12217 
 
12218 
  def read(self, iprot):
12219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12221 
      return
12222 
    iprot.readStructBegin()
12223 
    while True:
12224 
      (fname, ftype, fid) = iprot.readFieldBegin()
12225 
      if ftype == TType.STOP:
12226 
        break
12227 
      if fid == 1:
12228 
        if ftype == TType.I64:
12229 
          self.customer_id = iprot.readI64();
12230 
        else:
12231 
          iprot.skip(ftype)
12232 
      elif fid == 2:
12233 
        if ftype == TType.I64:
12234 
          self.limit = iprot.readI64();
12235 
        else:
12236 
          iprot.skip(ftype)
12237 
      else:
12238 
        iprot.skip(ftype)
12239 
      iprot.readFieldEnd()
12240 
    iprot.readStructEnd()
12241 
 
12242 
  def write(self, oprot):
12243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12245 
      return
12246 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 12247 
    if self.customer_id is not None:
1382 varun.gupt 12248 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
12249 
      oprot.writeI64(self.customer_id)
12250 
      oprot.writeFieldEnd()
3431 rajveer 12251 
    if self.limit is not None:
1382 varun.gupt 12252 
      oprot.writeFieldBegin('limit', TType.I64, 2)
12253 
      oprot.writeI64(self.limit)
12254 
      oprot.writeFieldEnd()
12255 
    oprot.writeFieldStop()
12256 
    oprot.writeStructEnd()
12257 
 
3431 rajveer 12258 
  def validate(self):
12259 
    return
12260 
 
12261 
 
1382 varun.gupt 12262 
  def __repr__(self):
12263 
    L = ['%s=%r' % (key, value)
12264 
      for key, value in self.__dict__.iteritems()]
12265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12266 
 
12267 
  def __eq__(self, other):
12268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12269 
 
12270 
  def __ne__(self, other):
12271 
    return not (self == other)
12272 
 
12273 
class getCancellableOrdersForCustomer_result:
12274 
  """
12275 
  Attributes:
12276 
   - success
12277 
   - ex
12278 
  """
12279 
 
12280 
  thrift_spec = (
12281 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12282 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12283 
  )
12284 
 
12285 
  def __init__(self, success=None, ex=None,):
12286 
    self.success = success
12287 
    self.ex = ex
12288 
 
12289 
  def read(self, iprot):
12290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12292 
      return
12293 
    iprot.readStructBegin()
12294 
    while True:
12295 
      (fname, ftype, fid) = iprot.readFieldBegin()
12296 
      if ftype == TType.STOP:
12297 
        break
12298 
      if fid == 0:
12299 
        if ftype == TType.LIST:
12300 
          self.success = []
6188 rajveer 12301 
          (_etype179, _size176) = iprot.readListBegin()
12302 
          for _i180 in xrange(_size176):
12303 
            _elem181 = iprot.readI64();
12304 
            self.success.append(_elem181)
1382 varun.gupt 12305 
          iprot.readListEnd()
12306 
        else:
12307 
          iprot.skip(ftype)
12308 
      elif fid == 1:
12309 
        if ftype == TType.STRUCT:
12310 
          self.ex = TransactionServiceException()
12311 
          self.ex.read(iprot)
12312 
        else:
12313 
          iprot.skip(ftype)
12314 
      else:
12315 
        iprot.skip(ftype)
12316 
      iprot.readFieldEnd()
12317 
    iprot.readStructEnd()
12318 
 
12319 
  def write(self, oprot):
12320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12322 
      return
12323 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 12324 
    if self.success is not None:
1382 varun.gupt 12325 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12326 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 12327 
      for iter182 in self.success:
12328 
        oprot.writeI64(iter182)
1382 varun.gupt 12329 
      oprot.writeListEnd()
12330 
      oprot.writeFieldEnd()
3431 rajveer 12331 
    if self.ex is not None:
1382 varun.gupt 12332 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12333 
      self.ex.write(oprot)
12334 
      oprot.writeFieldEnd()
12335 
    oprot.writeFieldStop()
12336 
    oprot.writeStructEnd()
12337 
 
3431 rajveer 12338 
  def validate(self):
12339 
    return
12340 
 
12341 
 
1382 varun.gupt 12342 
  def __repr__(self):
12343 
    L = ['%s=%r' % (key, value)
12344 
      for key, value in self.__dict__.iteritems()]
12345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12346 
 
12347 
  def __eq__(self, other):
12348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12349 
 
12350 
  def __ne__(self, other):
12351 
    return not (self == other)
12352 
 
483 rajveer 12353 
class changeOrderStatus_args:
94 ashish 12354 
  """
12355 
  Attributes:
483 rajveer 12356 
   - orderId
12357 
   - status
12358 
   - description
94 ashish 12359 
  """
12360 
 
12361 
  thrift_spec = (
12362 
    None, # 0
483 rajveer 12363 
    (1, TType.I64, 'orderId', None, None, ), # 1
12364 
    (2, TType.I32, 'status', None, None, ), # 2
12365 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12366 
  )
12367 
 
483 rajveer 12368 
  def __init__(self, orderId=None, status=None, description=None,):
12369 
    self.orderId = orderId
12370 
    self.status = status
12371 
    self.description = description
94 ashish 12372 
 
12373 
  def read(self, iprot):
12374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12376 
      return
12377 
    iprot.readStructBegin()
12378 
    while True:
12379 
      (fname, ftype, fid) = iprot.readFieldBegin()
12380 
      if ftype == TType.STOP:
12381 
        break
12382 
      if fid == 1:
12383 
        if ftype == TType.I64:
483 rajveer 12384 
          self.orderId = iprot.readI64();
94 ashish 12385 
        else:
12386 
          iprot.skip(ftype)
12387 
      elif fid == 2:
483 rajveer 12388 
        if ftype == TType.I32:
12389 
          self.status = iprot.readI32();
94 ashish 12390 
        else:
12391 
          iprot.skip(ftype)
483 rajveer 12392 
      elif fid == 3:
12393 
        if ftype == TType.STRING:
12394 
          self.description = iprot.readString();
12395 
        else:
12396 
          iprot.skip(ftype)
94 ashish 12397 
      else:
12398 
        iprot.skip(ftype)
12399 
      iprot.readFieldEnd()
12400 
    iprot.readStructEnd()
12401 
 
12402 
  def write(self, oprot):
12403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12405 
      return
483 rajveer 12406 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 12407 
    if self.orderId is not None:
483 rajveer 12408 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12409 
      oprot.writeI64(self.orderId)
94 ashish 12410 
      oprot.writeFieldEnd()
3431 rajveer 12411 
    if self.status is not None:
483 rajveer 12412 
      oprot.writeFieldBegin('status', TType.I32, 2)
12413 
      oprot.writeI32(self.status)
94 ashish 12414 
      oprot.writeFieldEnd()
3431 rajveer 12415 
    if self.description is not None:
483 rajveer 12416 
      oprot.writeFieldBegin('description', TType.STRING, 3)
12417 
      oprot.writeString(self.description)
12418 
      oprot.writeFieldEnd()
94 ashish 12419 
    oprot.writeFieldStop()
12420 
    oprot.writeStructEnd()
12421 
 
3431 rajveer 12422 
  def validate(self):
12423 
    return
12424 
 
12425 
 
94 ashish 12426 
  def __repr__(self):
12427 
    L = ['%s=%r' % (key, value)
12428 
      for key, value in self.__dict__.iteritems()]
12429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12430 
 
12431 
  def __eq__(self, other):
12432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12433 
 
12434 
  def __ne__(self, other):
12435 
    return not (self == other)
12436 
 
483 rajveer 12437 
class changeOrderStatus_result:
94 ashish 12438 
  """
12439 
  Attributes:
12440 
   - success
12441 
   - ex
12442 
  """
12443 
 
12444 
  thrift_spec = (
12445 
    (0, TType.BOOL, 'success', None, None, ), # 0
12446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12447 
  )
12448 
 
12449 
  def __init__(self, success=None, ex=None,):
12450 
    self.success = success
12451 
    self.ex = ex
12452 
 
12453 
  def read(self, iprot):
12454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12456 
      return
12457 
    iprot.readStructBegin()
12458 
    while True:
12459 
      (fname, ftype, fid) = iprot.readFieldBegin()
12460 
      if ftype == TType.STOP:
12461 
        break
12462 
      if fid == 0:
12463 
        if ftype == TType.BOOL:
12464 
          self.success = iprot.readBool();
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
483 rajveer 12482 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 12483 
    if self.success is not None:
94 ashish 12484 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12485 
      oprot.writeBool(self.success)
12486 
      oprot.writeFieldEnd()
3431 rajveer 12487 
    if self.ex is not None:
94 ashish 12488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12489 
      self.ex.write(oprot)
12490 
      oprot.writeFieldEnd()
12491 
    oprot.writeFieldStop()
12492 
    oprot.writeStructEnd()
12493 
 
3431 rajveer 12494 
  def validate(self):
12495 
    return
12496 
 
12497 
 
94 ashish 12498 
  def __repr__(self):
12499 
    L = ['%s=%r' % (key, value)
12500 
      for key, value in self.__dict__.iteritems()]
12501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12502 
 
12503 
  def __eq__(self, other):
12504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12505 
 
12506 
  def __ne__(self, other):
12507 
    return not (self == other)
12508 
 
3064 chandransh 12509 
class getOrdersForTransaction_args:
494 rajveer 12510 
  """
12511 
  Attributes:
3064 chandransh 12512 
   - transactionId
12513 
   - customerId
494 rajveer 12514 
  """
12515 
 
12516 
  thrift_spec = (
12517 
    None, # 0
3064 chandransh 12518 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12519 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 12520 
  )
12521 
 
3064 chandransh 12522 
  def __init__(self, transactionId=None, customerId=None,):
12523 
    self.transactionId = transactionId
12524 
    self.customerId = customerId
494 rajveer 12525 
 
12526 
  def read(self, iprot):
12527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12529 
      return
12530 
    iprot.readStructBegin()
12531 
    while True:
12532 
      (fname, ftype, fid) = iprot.readFieldBegin()
12533 
      if ftype == TType.STOP:
12534 
        break
12535 
      if fid == 1:
12536 
        if ftype == TType.I64:
3064 chandransh 12537 
          self.transactionId = iprot.readI64();
494 rajveer 12538 
        else:
12539 
          iprot.skip(ftype)
12540 
      elif fid == 2:
3064 chandransh 12541 
        if ftype == TType.I64:
12542 
          self.customerId = iprot.readI64();
494 rajveer 12543 
        else:
12544 
          iprot.skip(ftype)
12545 
      else:
12546 
        iprot.skip(ftype)
12547 
      iprot.readFieldEnd()
12548 
    iprot.readStructEnd()
12549 
 
12550 
  def write(self, oprot):
12551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12553 
      return
3064 chandransh 12554 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 12555 
    if self.transactionId is not None:
3064 chandransh 12556 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12557 
      oprot.writeI64(self.transactionId)
494 rajveer 12558 
      oprot.writeFieldEnd()
3431 rajveer 12559 
    if self.customerId is not None:
3064 chandransh 12560 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
12561 
      oprot.writeI64(self.customerId)
494 rajveer 12562 
      oprot.writeFieldEnd()
12563 
    oprot.writeFieldStop()
12564 
    oprot.writeStructEnd()
12565 
 
3431 rajveer 12566 
  def validate(self):
12567 
    return
12568 
 
12569 
 
494 rajveer 12570 
  def __repr__(self):
12571 
    L = ['%s=%r' % (key, value)
12572 
      for key, value in self.__dict__.iteritems()]
12573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12574 
 
12575 
  def __eq__(self, other):
12576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12577 
 
12578 
  def __ne__(self, other):
12579 
    return not (self == other)
12580 
 
3064 chandransh 12581 
class getOrdersForTransaction_result:
494 rajveer 12582 
  """
12583 
  Attributes:
12584 
   - success
12585 
   - ex
12586 
  """
12587 
 
12588 
  thrift_spec = (
3064 chandransh 12589 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 12590 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12591 
  )
12592 
 
12593 
  def __init__(self, success=None, ex=None,):
12594 
    self.success = success
12595 
    self.ex = ex
12596 
 
12597 
  def read(self, iprot):
12598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12600 
      return
12601 
    iprot.readStructBegin()
12602 
    while True:
12603 
      (fname, ftype, fid) = iprot.readFieldBegin()
12604 
      if ftype == TType.STOP:
12605 
        break
12606 
      if fid == 0:
3064 chandransh 12607 
        if ftype == TType.LIST:
12608 
          self.success = []
6188 rajveer 12609 
          (_etype186, _size183) = iprot.readListBegin()
12610 
          for _i187 in xrange(_size183):
12611 
            _elem188 = Order()
12612 
            _elem188.read(iprot)
12613 
            self.success.append(_elem188)
3064 chandransh 12614 
          iprot.readListEnd()
494 rajveer 12615 
        else:
12616 
          iprot.skip(ftype)
12617 
      elif fid == 1:
12618 
        if ftype == TType.STRUCT:
12619 
          self.ex = TransactionServiceException()
12620 
          self.ex.read(iprot)
12621 
        else:
12622 
          iprot.skip(ftype)
12623 
      else:
12624 
        iprot.skip(ftype)
12625 
      iprot.readFieldEnd()
12626 
    iprot.readStructEnd()
12627 
 
12628 
  def write(self, oprot):
12629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12631 
      return
3064 chandransh 12632 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 12633 
    if self.success is not None:
3064 chandransh 12634 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12635 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12636 
      for iter189 in self.success:
12637 
        iter189.write(oprot)
3064 chandransh 12638 
      oprot.writeListEnd()
494 rajveer 12639 
      oprot.writeFieldEnd()
3431 rajveer 12640 
    if self.ex is not None:
494 rajveer 12641 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12642 
      self.ex.write(oprot)
12643 
      oprot.writeFieldEnd()
12644 
    oprot.writeFieldStop()
12645 
    oprot.writeStructEnd()
12646 
 
3431 rajveer 12647 
  def validate(self):
12648 
    return
12649 
 
12650 
 
494 rajveer 12651 
  def __repr__(self):
12652 
    L = ['%s=%r' % (key, value)
12653 
      for key, value in self.__dict__.iteritems()]
12654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12655 
 
12656 
  def __eq__(self, other):
12657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12658 
 
12659 
  def __ne__(self, other):
12660 
    return not (self == other)
12661 
 
3064 chandransh 12662 
class getOrdersForCustomer_args:
1149 chandransh 12663 
  """
12664 
  Attributes:
3064 chandransh 12665 
   - customerId
12666 
   - from_date
12667 
   - to_date
12668 
   - statuses
1149 chandransh 12669 
  """
12670 
 
12671 
  thrift_spec = (
12672 
    None, # 0
3064 chandransh 12673 
    (1, TType.I64, 'customerId', None, None, ), # 1
12674 
    (2, TType.I64, 'from_date', None, None, ), # 2
12675 
    (3, TType.I64, 'to_date', None, None, ), # 3
12676 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 12677 
  )
12678 
 
3064 chandransh 12679 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
12680 
    self.customerId = customerId
12681 
    self.from_date = from_date
12682 
    self.to_date = to_date
12683 
    self.statuses = statuses
1149 chandransh 12684 
 
12685 
  def read(self, iprot):
12686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12688 
      return
12689 
    iprot.readStructBegin()
12690 
    while True:
12691 
      (fname, ftype, fid) = iprot.readFieldBegin()
12692 
      if ftype == TType.STOP:
12693 
        break
12694 
      if fid == 1:
12695 
        if ftype == TType.I64:
3064 chandransh 12696 
          self.customerId = iprot.readI64();
1149 chandransh 12697 
        else:
12698 
          iprot.skip(ftype)
12699 
      elif fid == 2:
12700 
        if ftype == TType.I64:
3064 chandransh 12701 
          self.from_date = iprot.readI64();
1149 chandransh 12702 
        else:
12703 
          iprot.skip(ftype)
2783 chandransh 12704 
      elif fid == 3:
12705 
        if ftype == TType.I64:
3064 chandransh 12706 
          self.to_date = iprot.readI64();
2783 chandransh 12707 
        else:
12708 
          iprot.skip(ftype)
12709 
      elif fid == 4:
3064 chandransh 12710 
        if ftype == TType.LIST:
12711 
          self.statuses = []
6188 rajveer 12712 
          (_etype193, _size190) = iprot.readListBegin()
12713 
          for _i194 in xrange(_size190):
12714 
            _elem195 = iprot.readI32();
12715 
            self.statuses.append(_elem195)
3064 chandransh 12716 
          iprot.readListEnd()
2783 chandransh 12717 
        else:
12718 
          iprot.skip(ftype)
1149 chandransh 12719 
      else:
12720 
        iprot.skip(ftype)
12721 
      iprot.readFieldEnd()
12722 
    iprot.readStructEnd()
12723 
 
12724 
  def write(self, oprot):
12725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12727 
      return
3064 chandransh 12728 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 12729 
    if self.customerId is not None:
3064 chandransh 12730 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
12731 
      oprot.writeI64(self.customerId)
1149 chandransh 12732 
      oprot.writeFieldEnd()
3431 rajveer 12733 
    if self.from_date is not None:
3064 chandransh 12734 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
12735 
      oprot.writeI64(self.from_date)
1149 chandransh 12736 
      oprot.writeFieldEnd()
3431 rajveer 12737 
    if self.to_date is not None:
3064 chandransh 12738 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
12739 
      oprot.writeI64(self.to_date)
2783 chandransh 12740 
      oprot.writeFieldEnd()
3431 rajveer 12741 
    if self.statuses is not None:
3064 chandransh 12742 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
12743 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 12744 
      for iter196 in self.statuses:
12745 
        oprot.writeI32(iter196)
3064 chandransh 12746 
      oprot.writeListEnd()
2783 chandransh 12747 
      oprot.writeFieldEnd()
1149 chandransh 12748 
    oprot.writeFieldStop()
12749 
    oprot.writeStructEnd()
12750 
 
3431 rajveer 12751 
  def validate(self):
12752 
    return
12753 
 
12754 
 
1149 chandransh 12755 
  def __repr__(self):
12756 
    L = ['%s=%r' % (key, value)
12757 
      for key, value in self.__dict__.iteritems()]
12758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12759 
 
12760 
  def __eq__(self, other):
12761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12762 
 
12763 
  def __ne__(self, other):
12764 
    return not (self == other)
12765 
 
3064 chandransh 12766 
class getOrdersForCustomer_result:
1149 chandransh 12767 
  """
12768 
  Attributes:
12769 
   - success
12770 
   - ex
12771 
  """
12772 
 
12773 
  thrift_spec = (
3064 chandransh 12774 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 12775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12776 
  )
12777 
 
12778 
  def __init__(self, success=None, ex=None,):
12779 
    self.success = success
12780 
    self.ex = ex
12781 
 
12782 
  def read(self, iprot):
12783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12785 
      return
12786 
    iprot.readStructBegin()
12787 
    while True:
12788 
      (fname, ftype, fid) = iprot.readFieldBegin()
12789 
      if ftype == TType.STOP:
12790 
        break
12791 
      if fid == 0:
3064 chandransh 12792 
        if ftype == TType.LIST:
12793 
          self.success = []
6188 rajveer 12794 
          (_etype200, _size197) = iprot.readListBegin()
12795 
          for _i201 in xrange(_size197):
12796 
            _elem202 = Order()
12797 
            _elem202.read(iprot)
12798 
            self.success.append(_elem202)
3064 chandransh 12799 
          iprot.readListEnd()
1149 chandransh 12800 
        else:
12801 
          iprot.skip(ftype)
12802 
      elif fid == 1:
12803 
        if ftype == TType.STRUCT:
12804 
          self.ex = TransactionServiceException()
12805 
          self.ex.read(iprot)
12806 
        else:
12807 
          iprot.skip(ftype)
12808 
      else:
12809 
        iprot.skip(ftype)
12810 
      iprot.readFieldEnd()
12811 
    iprot.readStructEnd()
12812 
 
12813 
  def write(self, oprot):
12814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12816 
      return
3064 chandransh 12817 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12818 
    if self.success is not None:
3064 chandransh 12819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12821 
      for iter203 in self.success:
12822 
        iter203.write(oprot)
3064 chandransh 12823 
      oprot.writeListEnd()
1149 chandransh 12824 
      oprot.writeFieldEnd()
3431 rajveer 12825 
    if self.ex is not None:
1149 chandransh 12826 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12827 
      self.ex.write(oprot)
12828 
      oprot.writeFieldEnd()
12829 
    oprot.writeFieldStop()
12830 
    oprot.writeStructEnd()
12831 
 
3431 rajveer 12832 
  def validate(self):
12833 
    return
12834 
 
12835 
 
1149 chandransh 12836 
  def __repr__(self):
12837 
    L = ['%s=%r' % (key, value)
12838 
      for key, value in self.__dict__.iteritems()]
12839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12840 
 
12841 
  def __eq__(self, other):
12842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12843 
 
12844 
  def __ne__(self, other):
12845 
    return not (self == other)
12846 
 
3064 chandransh 12847 
class createOrder_args:
921 rajveer 12848 
  """
12849 
  Attributes:
3064 chandransh 12850 
   - order
921 rajveer 12851 
  """
12852 
 
12853 
  thrift_spec = (
12854 
    None, # 0
3064 chandransh 12855 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12856 
  )
12857 
 
3064 chandransh 12858 
  def __init__(self, order=None,):
12859 
    self.order = order
921 rajveer 12860 
 
12861 
  def read(self, iprot):
12862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12864 
      return
12865 
    iprot.readStructBegin()
12866 
    while True:
12867 
      (fname, ftype, fid) = iprot.readFieldBegin()
12868 
      if ftype == TType.STOP:
12869 
        break
12870 
      if fid == 1:
3064 chandransh 12871 
        if ftype == TType.STRUCT:
12872 
          self.order = Order()
12873 
          self.order.read(iprot)
921 rajveer 12874 
        else:
12875 
          iprot.skip(ftype)
12876 
      else:
12877 
        iprot.skip(ftype)
12878 
      iprot.readFieldEnd()
12879 
    iprot.readStructEnd()
12880 
 
12881 
  def write(self, oprot):
12882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12884 
      return
3064 chandransh 12885 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12886 
    if self.order is not None:
3064 chandransh 12887 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12888 
      self.order.write(oprot)
921 rajveer 12889 
      oprot.writeFieldEnd()
12890 
    oprot.writeFieldStop()
12891 
    oprot.writeStructEnd()
12892 
 
3431 rajveer 12893 
  def validate(self):
12894 
    return
12895 
 
12896 
 
921 rajveer 12897 
  def __repr__(self):
12898 
    L = ['%s=%r' % (key, value)
12899 
      for key, value in self.__dict__.iteritems()]
12900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12901 
 
12902 
  def __eq__(self, other):
12903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12904 
 
12905 
  def __ne__(self, other):
12906 
    return not (self == other)
12907 
 
3064 chandransh 12908 
class createOrder_result:
921 rajveer 12909 
  """
12910 
  Attributes:
12911 
   - success
12912 
   - ex
12913 
  """
12914 
 
12915 
  thrift_spec = (
3064 chandransh 12916 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12917 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12918 
  )
12919 
 
12920 
  def __init__(self, success=None, ex=None,):
12921 
    self.success = success
12922 
    self.ex = ex
12923 
 
12924 
  def read(self, iprot):
12925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12927 
      return
12928 
    iprot.readStructBegin()
12929 
    while True:
12930 
      (fname, ftype, fid) = iprot.readFieldBegin()
12931 
      if ftype == TType.STOP:
12932 
        break
12933 
      if fid == 0:
3064 chandransh 12934 
        if ftype == TType.I64:
12935 
          self.success = iprot.readI64();
921 rajveer 12936 
        else:
12937 
          iprot.skip(ftype)
12938 
      elif fid == 1:
12939 
        if ftype == TType.STRUCT:
12940 
          self.ex = TransactionServiceException()
12941 
          self.ex.read(iprot)
12942 
        else:
12943 
          iprot.skip(ftype)
12944 
      else:
12945 
        iprot.skip(ftype)
12946 
      iprot.readFieldEnd()
12947 
    iprot.readStructEnd()
12948 
 
12949 
  def write(self, oprot):
12950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12952 
      return
3064 chandransh 12953 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12954 
    if self.success is not None:
3064 chandransh 12955 
      oprot.writeFieldBegin('success', TType.I64, 0)
12956 
      oprot.writeI64(self.success)
921 rajveer 12957 
      oprot.writeFieldEnd()
3431 rajveer 12958 
    if self.ex is not None:
921 rajveer 12959 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12960 
      self.ex.write(oprot)
12961 
      oprot.writeFieldEnd()
12962 
    oprot.writeFieldStop()
12963 
    oprot.writeStructEnd()
12964 
 
3431 rajveer 12965 
  def validate(self):
12966 
    return
12967 
 
12968 
 
921 rajveer 12969 
  def __repr__(self):
12970 
    L = ['%s=%r' % (key, value)
12971 
      for key, value in self.__dict__.iteritems()]
12972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12973 
 
12974 
  def __eq__(self, other):
12975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12976 
 
12977 
  def __ne__(self, other):
12978 
    return not (self == other)
12979 
 
3064 chandransh 12980 
class getOrder_args:
921 rajveer 12981 
  """
12982 
  Attributes:
3064 chandransh 12983 
   - id
921 rajveer 12984 
  """
12985 
 
12986 
  thrift_spec = (
12987 
    None, # 0
3064 chandransh 12988 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12989 
  )
12990 
 
3064 chandransh 12991 
  def __init__(self, id=None,):
12992 
    self.id = id
921 rajveer 12993 
 
12994 
  def read(self, iprot):
12995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12997 
      return
12998 
    iprot.readStructBegin()
12999 
    while True:
13000 
      (fname, ftype, fid) = iprot.readFieldBegin()
13001 
      if ftype == TType.STOP:
13002 
        break
13003 
      if fid == 1:
13004 
        if ftype == TType.I64:
3064 chandransh 13005 
          self.id = iprot.readI64();
921 rajveer 13006 
        else:
13007 
          iprot.skip(ftype)
13008 
      else:
13009 
        iprot.skip(ftype)
13010 
      iprot.readFieldEnd()
13011 
    iprot.readStructEnd()
13012 
 
13013 
  def write(self, oprot):
13014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13016 
      return
3064 chandransh 13017 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 13018 
    if self.id is not None:
3064 chandransh 13019 
      oprot.writeFieldBegin('id', TType.I64, 1)
13020 
      oprot.writeI64(self.id)
921 rajveer 13021 
      oprot.writeFieldEnd()
13022 
    oprot.writeFieldStop()
13023 
    oprot.writeStructEnd()
13024 
 
3431 rajveer 13025 
  def validate(self):
13026 
    return
13027 
 
13028 
 
921 rajveer 13029 
  def __repr__(self):
13030 
    L = ['%s=%r' % (key, value)
13031 
      for key, value in self.__dict__.iteritems()]
13032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13033 
 
13034 
  def __eq__(self, other):
13035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13036 
 
13037 
  def __ne__(self, other):
13038 
    return not (self == other)
13039 
 
3064 chandransh 13040 
class getOrder_result:
921 rajveer 13041 
  """
13042 
  Attributes:
13043 
   - success
13044 
   - ex
13045 
  """
13046 
 
13047 
  thrift_spec = (
3064 chandransh 13048 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 13049 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13050 
  )
13051 
 
13052 
  def __init__(self, success=None, ex=None,):
13053 
    self.success = success
13054 
    self.ex = ex
13055 
 
13056 
  def read(self, iprot):
13057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13059 
      return
13060 
    iprot.readStructBegin()
13061 
    while True:
13062 
      (fname, ftype, fid) = iprot.readFieldBegin()
13063 
      if ftype == TType.STOP:
13064 
        break
13065 
      if fid == 0:
3064 chandransh 13066 
        if ftype == TType.STRUCT:
13067 
          self.success = Order()
13068 
          self.success.read(iprot)
921 rajveer 13069 
        else:
13070 
          iprot.skip(ftype)
13071 
      elif fid == 1:
13072 
        if ftype == TType.STRUCT:
13073 
          self.ex = TransactionServiceException()
13074 
          self.ex.read(iprot)
13075 
        else:
13076 
          iprot.skip(ftype)
13077 
      else:
13078 
        iprot.skip(ftype)
13079 
      iprot.readFieldEnd()
13080 
    iprot.readStructEnd()
13081 
 
13082 
  def write(self, oprot):
13083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13085 
      return
3064 chandransh 13086 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 13087 
    if self.success is not None:
3064 chandransh 13088 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13089 
      self.success.write(oprot)
921 rajveer 13090 
      oprot.writeFieldEnd()
3431 rajveer 13091 
    if self.ex is not None:
921 rajveer 13092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13093 
      self.ex.write(oprot)
13094 
      oprot.writeFieldEnd()
13095 
    oprot.writeFieldStop()
13096 
    oprot.writeStructEnd()
13097 
 
3431 rajveer 13098 
  def validate(self):
13099 
    return
13100 
 
13101 
 
921 rajveer 13102 
  def __repr__(self):
13103 
    L = ['%s=%r' % (key, value)
13104 
      for key, value in self.__dict__.iteritems()]
13105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13106 
 
13107 
  def __eq__(self, other):
13108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13109 
 
13110 
  def __ne__(self, other):
13111 
    return not (self == other)
13112 
 
3064 chandransh 13113 
class getLineItemsForOrder_args:
94 ashish 13114 
  """
13115 
  Attributes:
3064 chandransh 13116 
   - orderId
94 ashish 13117 
  """
13118 
 
13119 
  thrift_spec = (
13120 
    None, # 0
3064 chandransh 13121 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 13122 
  )
13123 
 
3064 chandransh 13124 
  def __init__(self, orderId=None,):
13125 
    self.orderId = orderId
94 ashish 13126 
 
13127 
  def read(self, iprot):
13128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13130 
      return
13131 
    iprot.readStructBegin()
13132 
    while True:
13133 
      (fname, ftype, fid) = iprot.readFieldBegin()
13134 
      if ftype == TType.STOP:
13135 
        break
13136 
      if fid == 1:
13137 
        if ftype == TType.I64:
3064 chandransh 13138 
          self.orderId = iprot.readI64();
94 ashish 13139 
        else:
13140 
          iprot.skip(ftype)
13141 
      else:
13142 
        iprot.skip(ftype)
13143 
      iprot.readFieldEnd()
13144 
    iprot.readStructEnd()
13145 
 
13146 
  def write(self, oprot):
13147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13149 
      return
3064 chandransh 13150 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 13151 
    if self.orderId is not None:
3064 chandransh 13152 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13153 
      oprot.writeI64(self.orderId)
94 ashish 13154 
      oprot.writeFieldEnd()
13155 
    oprot.writeFieldStop()
13156 
    oprot.writeStructEnd()
13157 
 
3431 rajveer 13158 
  def validate(self):
13159 
    return
13160 
 
13161 
 
94 ashish 13162 
  def __repr__(self):
13163 
    L = ['%s=%r' % (key, value)
13164 
      for key, value in self.__dict__.iteritems()]
13165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13166 
 
13167 
  def __eq__(self, other):
13168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13169 
 
13170 
  def __ne__(self, other):
13171 
    return not (self == other)
13172 
 
3064 chandransh 13173 
class getLineItemsForOrder_result:
94 ashish 13174 
  """
13175 
  Attributes:
13176 
   - success
13177 
   - ex
13178 
  """
13179 
 
13180 
  thrift_spec = (
3064 chandransh 13181 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 13182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13183 
  )
13184 
 
13185 
  def __init__(self, success=None, ex=None,):
13186 
    self.success = success
13187 
    self.ex = ex
13188 
 
13189 
  def read(self, iprot):
13190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13192 
      return
13193 
    iprot.readStructBegin()
13194 
    while True:
13195 
      (fname, ftype, fid) = iprot.readFieldBegin()
13196 
      if ftype == TType.STOP:
13197 
        break
13198 
      if fid == 0:
483 rajveer 13199 
        if ftype == TType.LIST:
13200 
          self.success = []
6188 rajveer 13201 
          (_etype207, _size204) = iprot.readListBegin()
13202 
          for _i208 in xrange(_size204):
13203 
            _elem209 = LineItem()
13204 
            _elem209.read(iprot)
13205 
            self.success.append(_elem209)
483 rajveer 13206 
          iprot.readListEnd()
94 ashish 13207 
        else:
13208 
          iprot.skip(ftype)
13209 
      elif fid == 1:
13210 
        if ftype == TType.STRUCT:
13211 
          self.ex = TransactionServiceException()
13212 
          self.ex.read(iprot)
13213 
        else:
13214 
          iprot.skip(ftype)
13215 
      else:
13216 
        iprot.skip(ftype)
13217 
      iprot.readFieldEnd()
13218 
    iprot.readStructEnd()
13219 
 
13220 
  def write(self, oprot):
13221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13223 
      return
3064 chandransh 13224 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 13225 
    if self.success is not None:
483 rajveer 13226 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13227 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13228 
      for iter210 in self.success:
13229 
        iter210.write(oprot)
483 rajveer 13230 
      oprot.writeListEnd()
94 ashish 13231 
      oprot.writeFieldEnd()
3431 rajveer 13232 
    if self.ex is not None:
94 ashish 13233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13234 
      self.ex.write(oprot)
13235 
      oprot.writeFieldEnd()
13236 
    oprot.writeFieldStop()
13237 
    oprot.writeStructEnd()
13238 
 
3431 rajveer 13239 
  def validate(self):
13240 
    return
13241 
 
13242 
 
94 ashish 13243 
  def __repr__(self):
13244 
    L = ['%s=%r' % (key, value)
13245 
      for key, value in self.__dict__.iteritems()]
13246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13247 
 
13248 
  def __eq__(self, other):
13249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13250 
 
13251 
  def __ne__(self, other):
13252 
    return not (self == other)
13253 
 
4999 phani.kuma 13254 
class getOrderList_args:
13255 
  """
13256 
  Attributes:
13257 
   - order_ids
13258 
  """
13259 
 
13260 
  thrift_spec = (
13261 
    None, # 0
13262 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
13263 
  )
13264 
 
13265 
  def __init__(self, order_ids=None,):
13266 
    self.order_ids = order_ids
13267 
 
13268 
  def read(self, iprot):
13269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13271 
      return
13272 
    iprot.readStructBegin()
13273 
    while True:
13274 
      (fname, ftype, fid) = iprot.readFieldBegin()
13275 
      if ftype == TType.STOP:
13276 
        break
13277 
      if fid == 1:
13278 
        if ftype == TType.LIST:
13279 
          self.order_ids = []
6188 rajveer 13280 
          (_etype214, _size211) = iprot.readListBegin()
13281 
          for _i215 in xrange(_size211):
13282 
            _elem216 = iprot.readI64();
13283 
            self.order_ids.append(_elem216)
4999 phani.kuma 13284 
          iprot.readListEnd()
13285 
        else:
13286 
          iprot.skip(ftype)
13287 
      else:
13288 
        iprot.skip(ftype)
13289 
      iprot.readFieldEnd()
13290 
    iprot.readStructEnd()
13291 
 
13292 
  def write(self, oprot):
13293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13295 
      return
13296 
    oprot.writeStructBegin('getOrderList_args')
13297 
    if self.order_ids is not None:
13298 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
13299 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 13300 
      for iter217 in self.order_ids:
13301 
        oprot.writeI64(iter217)
4999 phani.kuma 13302 
      oprot.writeListEnd()
13303 
      oprot.writeFieldEnd()
13304 
    oprot.writeFieldStop()
13305 
    oprot.writeStructEnd()
13306 
 
13307 
  def validate(self):
13308 
    return
13309 
 
13310 
 
13311 
  def __repr__(self):
13312 
    L = ['%s=%r' % (key, value)
13313 
      for key, value in self.__dict__.iteritems()]
13314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13315 
 
13316 
  def __eq__(self, other):
13317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13318 
 
13319 
  def __ne__(self, other):
13320 
    return not (self == other)
13321 
 
13322 
class getOrderList_result:
13323 
  """
13324 
  Attributes:
13325 
   - success
13326 
  """
13327 
 
13328 
  thrift_spec = (
13329 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13330 
  )
13331 
 
13332 
  def __init__(self, success=None,):
13333 
    self.success = success
13334 
 
13335 
  def read(self, iprot):
13336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13338 
      return
13339 
    iprot.readStructBegin()
13340 
    while True:
13341 
      (fname, ftype, fid) = iprot.readFieldBegin()
13342 
      if ftype == TType.STOP:
13343 
        break
13344 
      if fid == 0:
13345 
        if ftype == TType.LIST:
13346 
          self.success = []
6188 rajveer 13347 
          (_etype221, _size218) = iprot.readListBegin()
13348 
          for _i222 in xrange(_size218):
13349 
            _elem223 = Order()
13350 
            _elem223.read(iprot)
13351 
            self.success.append(_elem223)
4999 phani.kuma 13352 
          iprot.readListEnd()
13353 
        else:
13354 
          iprot.skip(ftype)
13355 
      else:
13356 
        iprot.skip(ftype)
13357 
      iprot.readFieldEnd()
13358 
    iprot.readStructEnd()
13359 
 
13360 
  def write(self, oprot):
13361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13363 
      return
13364 
    oprot.writeStructBegin('getOrderList_result')
13365 
    if self.success is not None:
13366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13367 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13368 
      for iter224 in self.success:
13369 
        iter224.write(oprot)
4999 phani.kuma 13370 
      oprot.writeListEnd()
13371 
      oprot.writeFieldEnd()
13372 
    oprot.writeFieldStop()
13373 
    oprot.writeStructEnd()
13374 
 
13375 
  def validate(self):
13376 
    return
13377 
 
13378 
 
13379 
  def __repr__(self):
13380 
    L = ['%s=%r' % (key, value)
13381 
      for key, value in self.__dict__.iteritems()]
13382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13383 
 
13384 
  def __eq__(self, other):
13385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13386 
 
13387 
  def __ne__(self, other):
13388 
    return not (self == other)
13389 
 
5386 phani.kuma 13390 
class getOrderListForVendor_args:
13391 
  """
13392 
  Attributes:
13393 
   - order_ids
13394 
   - vendorId
13395 
  """
13396 
 
13397 
  thrift_spec = (
13398 
    None, # 0
13399 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
13400 
    (2, TType.I64, 'vendorId', None, None, ), # 2
13401 
  )
13402 
 
13403 
  def __init__(self, order_ids=None, vendorId=None,):
13404 
    self.order_ids = order_ids
13405 
    self.vendorId = vendorId
13406 
 
13407 
  def read(self, iprot):
13408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13410 
      return
13411 
    iprot.readStructBegin()
13412 
    while True:
13413 
      (fname, ftype, fid) = iprot.readFieldBegin()
13414 
      if ftype == TType.STOP:
13415 
        break
13416 
      if fid == 1:
13417 
        if ftype == TType.LIST:
13418 
          self.order_ids = []
6188 rajveer 13419 
          (_etype228, _size225) = iprot.readListBegin()
13420 
          for _i229 in xrange(_size225):
13421 
            _elem230 = iprot.readI64();
13422 
            self.order_ids.append(_elem230)
5386 phani.kuma 13423 
          iprot.readListEnd()
13424 
        else:
13425 
          iprot.skip(ftype)
13426 
      elif fid == 2:
13427 
        if ftype == TType.I64:
13428 
          self.vendorId = iprot.readI64();
13429 
        else:
13430 
          iprot.skip(ftype)
13431 
      else:
13432 
        iprot.skip(ftype)
13433 
      iprot.readFieldEnd()
13434 
    iprot.readStructEnd()
13435 
 
13436 
  def write(self, oprot):
13437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13439 
      return
13440 
    oprot.writeStructBegin('getOrderListForVendor_args')
13441 
    if self.order_ids is not None:
13442 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
13443 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 13444 
      for iter231 in self.order_ids:
13445 
        oprot.writeI64(iter231)
5386 phani.kuma 13446 
      oprot.writeListEnd()
13447 
      oprot.writeFieldEnd()
13448 
    if self.vendorId is not None:
13449 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
13450 
      oprot.writeI64(self.vendorId)
13451 
      oprot.writeFieldEnd()
13452 
    oprot.writeFieldStop()
13453 
    oprot.writeStructEnd()
13454 
 
13455 
  def validate(self):
13456 
    return
13457 
 
13458 
 
13459 
  def __repr__(self):
13460 
    L = ['%s=%r' % (key, value)
13461 
      for key, value in self.__dict__.iteritems()]
13462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13463 
 
13464 
  def __eq__(self, other):
13465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13466 
 
13467 
  def __ne__(self, other):
13468 
    return not (self == other)
13469 
 
13470 
class getOrderListForVendor_result:
13471 
  """
13472 
  Attributes:
13473 
   - success
13474 
  """
13475 
 
13476 
  thrift_spec = (
13477 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13478 
  )
13479 
 
13480 
  def __init__(self, success=None,):
13481 
    self.success = success
13482 
 
13483 
  def read(self, iprot):
13484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13486 
      return
13487 
    iprot.readStructBegin()
13488 
    while True:
13489 
      (fname, ftype, fid) = iprot.readFieldBegin()
13490 
      if ftype == TType.STOP:
13491 
        break
13492 
      if fid == 0:
13493 
        if ftype == TType.LIST:
13494 
          self.success = []
6188 rajveer 13495 
          (_etype235, _size232) = iprot.readListBegin()
13496 
          for _i236 in xrange(_size232):
13497 
            _elem237 = Order()
13498 
            _elem237.read(iprot)
13499 
            self.success.append(_elem237)
5386 phani.kuma 13500 
          iprot.readListEnd()
13501 
        else:
13502 
          iprot.skip(ftype)
13503 
      else:
13504 
        iprot.skip(ftype)
13505 
      iprot.readFieldEnd()
13506 
    iprot.readStructEnd()
13507 
 
13508 
  def write(self, oprot):
13509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13511 
      return
13512 
    oprot.writeStructBegin('getOrderListForVendor_result')
13513 
    if self.success is not None:
13514 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13515 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13516 
      for iter238 in self.success:
13517 
        iter238.write(oprot)
5386 phani.kuma 13518 
      oprot.writeListEnd()
13519 
      oprot.writeFieldEnd()
13520 
    oprot.writeFieldStop()
13521 
    oprot.writeStructEnd()
13522 
 
13523 
  def validate(self):
13524 
    return
13525 
 
13526 
 
13527 
  def __repr__(self):
13528 
    L = ['%s=%r' % (key, value)
13529 
      for key, value in self.__dict__.iteritems()]
13530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13531 
 
13532 
  def __eq__(self, other):
13533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13534 
 
13535 
  def __ne__(self, other):
13536 
    return not (self == other)
13537 
 
3064 chandransh 13538 
class getOrderForCustomer_args:
94 ashish 13539 
  """
13540 
  Attributes:
3064 chandransh 13541 
   - orderId
483 rajveer 13542 
   - customerId
94 ashish 13543 
  """
13544 
 
13545 
  thrift_spec = (
13546 
    None, # 0
3064 chandransh 13547 
    (1, TType.I64, 'orderId', None, None, ), # 1
13548 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 13549 
  )
13550 
 
3064 chandransh 13551 
  def __init__(self, orderId=None, customerId=None,):
13552 
    self.orderId = orderId
483 rajveer 13553 
    self.customerId = customerId
94 ashish 13554 
 
13555 
  def read(self, iprot):
13556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13558 
      return
13559 
    iprot.readStructBegin()
13560 
    while True:
13561 
      (fname, ftype, fid) = iprot.readFieldBegin()
13562 
      if ftype == TType.STOP:
13563 
        break
13564 
      if fid == 1:
13565 
        if ftype == TType.I64:
3064 chandransh 13566 
          self.orderId = iprot.readI64();
94 ashish 13567 
        else:
13568 
          iprot.skip(ftype)
13569 
      elif fid == 2:
13570 
        if ftype == TType.I64:
3064 chandransh 13571 
          self.customerId = iprot.readI64();
94 ashish 13572 
        else:
13573 
          iprot.skip(ftype)
13574 
      else:
13575 
        iprot.skip(ftype)
13576 
      iprot.readFieldEnd()
13577 
    iprot.readStructEnd()
13578 
 
13579 
  def write(self, oprot):
13580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13582 
      return
3064 chandransh 13583 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 13584 
    if self.orderId is not None:
3064 chandransh 13585 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13586 
      oprot.writeI64(self.orderId)
13587 
      oprot.writeFieldEnd()
3431 rajveer 13588 
    if self.customerId is not None:
3064 chandransh 13589 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 13590 
      oprot.writeI64(self.customerId)
94 ashish 13591 
      oprot.writeFieldEnd()
13592 
    oprot.writeFieldStop()
13593 
    oprot.writeStructEnd()
13594 
 
3431 rajveer 13595 
  def validate(self):
13596 
    return
13597 
 
13598 
 
94 ashish 13599 
  def __repr__(self):
13600 
    L = ['%s=%r' % (key, value)
13601 
      for key, value in self.__dict__.iteritems()]
13602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13603 
 
13604 
  def __eq__(self, other):
13605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13606 
 
13607 
  def __ne__(self, other):
13608 
    return not (self == other)
13609 
 
3064 chandransh 13610 
class getOrderForCustomer_result:
94 ashish 13611 
  """
13612 
  Attributes:
13613 
   - success
13614 
   - ex
13615 
  """
13616 
 
13617 
  thrift_spec = (
3064 chandransh 13618 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 13619 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13620 
  )
13621 
 
13622 
  def __init__(self, success=None, ex=None,):
13623 
    self.success = success
13624 
    self.ex = ex
13625 
 
13626 
  def read(self, iprot):
13627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13629 
      return
13630 
    iprot.readStructBegin()
13631 
    while True:
13632 
      (fname, ftype, fid) = iprot.readFieldBegin()
13633 
      if ftype == TType.STOP:
13634 
        break
13635 
      if fid == 0:
3064 chandransh 13636 
        if ftype == TType.STRUCT:
13637 
          self.success = Order()
13638 
          self.success.read(iprot)
94 ashish 13639 
        else:
13640 
          iprot.skip(ftype)
13641 
      elif fid == 1:
13642 
        if ftype == TType.STRUCT:
13643 
          self.ex = TransactionServiceException()
13644 
          self.ex.read(iprot)
13645 
        else:
13646 
          iprot.skip(ftype)
13647 
      else:
13648 
        iprot.skip(ftype)
13649 
      iprot.readFieldEnd()
13650 
    iprot.readStructEnd()
13651 
 
13652 
  def write(self, oprot):
13653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13655 
      return
3064 chandransh 13656 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 13657 
    if self.success is not None:
3064 chandransh 13658 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13659 
      self.success.write(oprot)
94 ashish 13660 
      oprot.writeFieldEnd()
3431 rajveer 13661 
    if self.ex is not None:
94 ashish 13662 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13663 
      self.ex.write(oprot)
13664 
      oprot.writeFieldEnd()
13665 
    oprot.writeFieldStop()
13666 
    oprot.writeStructEnd()
13667 
 
3431 rajveer 13668 
  def validate(self):
13669 
    return
13670 
 
13671 
 
94 ashish 13672 
  def __repr__(self):
13673 
    L = ['%s=%r' % (key, value)
13674 
      for key, value in self.__dict__.iteritems()]
13675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13676 
 
13677 
  def __eq__(self, other):
13678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13679 
 
13680 
  def __ne__(self, other):
13681 
    return not (self == other)
13682 
 
3064 chandransh 13683 
class getAlerts_args:
94 ashish 13684 
  """
13685 
  Attributes:
4394 rajveer 13686 
   - type
4444 rajveer 13687 
   - warehouseId
4394 rajveer 13688 
   - status
13689 
   - timestamp
94 ashish 13690 
  """
13691 
 
13692 
  thrift_spec = (
13693 
    None, # 0
4394 rajveer 13694 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13695 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13696 
    (3, TType.I64, 'status', None, None, ), # 3
13697 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 13698 
  )
13699 
 
4444 rajveer 13700 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 13701 
    self.type = type
4444 rajveer 13702 
    self.warehouseId = warehouseId
4394 rajveer 13703 
    self.status = status
13704 
    self.timestamp = timestamp
94 ashish 13705 
 
13706 
  def read(self, iprot):
13707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13709 
      return
13710 
    iprot.readStructBegin()
13711 
    while True:
13712 
      (fname, ftype, fid) = iprot.readFieldBegin()
13713 
      if ftype == TType.STOP:
13714 
        break
13715 
      if fid == 1:
3064 chandransh 13716 
        if ftype == TType.I64:
4394 rajveer 13717 
          self.type = iprot.readI64();
94 ashish 13718 
        else:
13719 
          iprot.skip(ftype)
3064 chandransh 13720 
      elif fid == 2:
4394 rajveer 13721 
        if ftype == TType.I64:
4444 rajveer 13722 
          self.warehouseId = iprot.readI64();
3064 chandransh 13723 
        else:
13724 
          iprot.skip(ftype)
4394 rajveer 13725 
      elif fid == 3:
13726 
        if ftype == TType.I64:
4444 rajveer 13727 
          self.status = iprot.readI64();
13728 
        else:
13729 
          iprot.skip(ftype)
13730 
      elif fid == 4:
13731 
        if ftype == TType.I64:
4394 rajveer 13732 
          self.timestamp = iprot.readI64();
13733 
        else:
13734 
          iprot.skip(ftype)
94 ashish 13735 
      else:
13736 
        iprot.skip(ftype)
13737 
      iprot.readFieldEnd()
13738 
    iprot.readStructEnd()
13739 
 
13740 
  def write(self, oprot):
13741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13743 
      return
3064 chandransh 13744 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 13745 
    if self.type is not None:
13746 
      oprot.writeFieldBegin('type', TType.I64, 1)
13747 
      oprot.writeI64(self.type)
94 ashish 13748 
      oprot.writeFieldEnd()
4444 rajveer 13749 
    if self.warehouseId is not None:
13750 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13751 
      oprot.writeI64(self.warehouseId)
13752 
      oprot.writeFieldEnd()
4394 rajveer 13753 
    if self.status is not None:
4444 rajveer 13754 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 13755 
      oprot.writeI64(self.status)
3064 chandransh 13756 
      oprot.writeFieldEnd()
4394 rajveer 13757 
    if self.timestamp is not None:
4444 rajveer 13758 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 13759 
      oprot.writeI64(self.timestamp)
13760 
      oprot.writeFieldEnd()
94 ashish 13761 
    oprot.writeFieldStop()
13762 
    oprot.writeStructEnd()
13763 
 
3431 rajveer 13764 
  def validate(self):
13765 
    return
13766 
 
13767 
 
94 ashish 13768 
  def __repr__(self):
13769 
    L = ['%s=%r' % (key, value)
13770 
      for key, value in self.__dict__.iteritems()]
13771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13772 
 
13773 
  def __eq__(self, other):
13774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13775 
 
13776 
  def __ne__(self, other):
13777 
    return not (self == other)
13778 
 
3064 chandransh 13779 
class getAlerts_result:
94 ashish 13780 
  """
13781 
  Attributes:
13782 
   - success
13783 
  """
13784 
 
13785 
  thrift_spec = (
3064 chandransh 13786 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 13787 
  )
13788 
 
3064 chandransh 13789 
  def __init__(self, success=None,):
94 ashish 13790 
    self.success = success
13791 
 
13792 
  def read(self, iprot):
13793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13795 
      return
13796 
    iprot.readStructBegin()
13797 
    while True:
13798 
      (fname, ftype, fid) = iprot.readFieldBegin()
13799 
      if ftype == TType.STOP:
13800 
        break
13801 
      if fid == 0:
3064 chandransh 13802 
        if ftype == TType.LIST:
13803 
          self.success = []
6188 rajveer 13804 
          (_etype242, _size239) = iprot.readListBegin()
13805 
          for _i243 in xrange(_size239):
13806 
            _elem244 = Alert()
13807 
            _elem244.read(iprot)
13808 
            self.success.append(_elem244)
3064 chandransh 13809 
          iprot.readListEnd()
94 ashish 13810 
        else:
13811 
          iprot.skip(ftype)
13812 
      else:
13813 
        iprot.skip(ftype)
13814 
      iprot.readFieldEnd()
13815 
    iprot.readStructEnd()
13816 
 
13817 
  def write(self, oprot):
13818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13820 
      return
3064 chandransh 13821 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13822 
    if self.success is not None:
3064 chandransh 13823 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13824 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13825 
      for iter245 in self.success:
13826 
        iter245.write(oprot)
3064 chandransh 13827 
      oprot.writeListEnd()
94 ashish 13828 
      oprot.writeFieldEnd()
13829 
    oprot.writeFieldStop()
13830 
    oprot.writeStructEnd()
13831 
 
3431 rajveer 13832 
  def validate(self):
13833 
    return
13834 
 
13835 
 
94 ashish 13836 
  def __repr__(self):
13837 
    L = ['%s=%r' % (key, value)
13838 
      for key, value in self.__dict__.iteritems()]
13839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13840 
 
13841 
  def __eq__(self, other):
13842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13843 
 
13844 
  def __ne__(self, other):
13845 
    return not (self == other)
13846 
 
4394 rajveer 13847 
class addAlert_args:
94 ashish 13848 
  """
13849 
  Attributes:
3064 chandransh 13850 
   - type
4444 rajveer 13851 
   - warehouseId
4394 rajveer 13852 
   - description
94 ashish 13853 
  """
13854 
 
13855 
  thrift_spec = (
13856 
    None, # 0
4394 rajveer 13857 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13858 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13859 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13860 
  )
13861 
 
4444 rajveer 13862 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13863 
    self.type = type
4444 rajveer 13864 
    self.warehouseId = warehouseId
4394 rajveer 13865 
    self.description = description
94 ashish 13866 
 
13867 
  def read(self, iprot):
13868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13870 
      return
13871 
    iprot.readStructBegin()
13872 
    while True:
13873 
      (fname, ftype, fid) = iprot.readFieldBegin()
13874 
      if ftype == TType.STOP:
13875 
        break
13876 
      if fid == 1:
13877 
        if ftype == TType.I64:
4394 rajveer 13878 
          self.type = iprot.readI64();
94 ashish 13879 
        else:
13880 
          iprot.skip(ftype)
3064 chandransh 13881 
      elif fid == 2:
4444 rajveer 13882 
        if ftype == TType.I64:
13883 
          self.warehouseId = iprot.readI64();
13884 
        else:
13885 
          iprot.skip(ftype)
13886 
      elif fid == 3:
3064 chandransh 13887 
        if ftype == TType.STRING:
4394 rajveer 13888 
          self.description = iprot.readString();
3064 chandransh 13889 
        else:
13890 
          iprot.skip(ftype)
94 ashish 13891 
      else:
13892 
        iprot.skip(ftype)
13893 
      iprot.readFieldEnd()
13894 
    iprot.readStructEnd()
13895 
 
13896 
  def write(self, oprot):
13897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13899 
      return
4394 rajveer 13900 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13901 
    if self.type is not None:
4394 rajveer 13902 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13903 
      oprot.writeI64(self.type)
13904 
      oprot.writeFieldEnd()
4444 rajveer 13905 
    if self.warehouseId is not None:
13906 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13907 
      oprot.writeI64(self.warehouseId)
13908 
      oprot.writeFieldEnd()
4394 rajveer 13909 
    if self.description is not None:
4444 rajveer 13910 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13911 
      oprot.writeString(self.description)
3064 chandransh 13912 
      oprot.writeFieldEnd()
94 ashish 13913 
    oprot.writeFieldStop()
13914 
    oprot.writeStructEnd()
13915 
 
3431 rajveer 13916 
  def validate(self):
13917 
    return
13918 
 
13919 
 
94 ashish 13920 
  def __repr__(self):
13921 
    L = ['%s=%r' % (key, value)
13922 
      for key, value in self.__dict__.iteritems()]
13923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13924 
 
13925 
  def __eq__(self, other):
13926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13927 
 
13928 
  def __ne__(self, other):
13929 
    return not (self == other)
13930 
 
4394 rajveer 13931 
class addAlert_result:
3064 chandransh 13932 
 
13933 
  thrift_spec = (
13934 
  )
13935 
 
13936 
  def read(self, iprot):
13937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13939 
      return
13940 
    iprot.readStructBegin()
13941 
    while True:
13942 
      (fname, ftype, fid) = iprot.readFieldBegin()
13943 
      if ftype == TType.STOP:
13944 
        break
13945 
      else:
13946 
        iprot.skip(ftype)
13947 
      iprot.readFieldEnd()
13948 
    iprot.readStructEnd()
13949 
 
13950 
  def write(self, oprot):
13951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13953 
      return
4394 rajveer 13954 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13955 
    oprot.writeFieldStop()
13956 
    oprot.writeStructEnd()
13957 
 
3431 rajveer 13958 
  def validate(self):
13959 
    return
13960 
 
13961 
 
3064 chandransh 13962 
  def __repr__(self):
13963 
    L = ['%s=%r' % (key, value)
13964 
      for key, value in self.__dict__.iteritems()]
13965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13966 
 
13967 
  def __eq__(self, other):
13968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13969 
 
13970 
  def __ne__(self, other):
13971 
    return not (self == other)
13972 
 
4444 rajveer 13973 
class markAlertsAsSeen_args:
13974 
  """
13975 
  Attributes:
13976 
   - warehouseId
13977 
  """
13978 
 
13979 
  thrift_spec = (
13980 
    None, # 0
13981 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13982 
  )
13983 
 
13984 
  def __init__(self, warehouseId=None,):
13985 
    self.warehouseId = warehouseId
13986 
 
13987 
  def read(self, iprot):
13988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13990 
      return
13991 
    iprot.readStructBegin()
13992 
    while True:
13993 
      (fname, ftype, fid) = iprot.readFieldBegin()
13994 
      if ftype == TType.STOP:
13995 
        break
13996 
      if fid == 1:
13997 
        if ftype == TType.I64:
13998 
          self.warehouseId = iprot.readI64();
13999 
        else:
14000 
          iprot.skip(ftype)
14001 
      else:
14002 
        iprot.skip(ftype)
14003 
      iprot.readFieldEnd()
14004 
    iprot.readStructEnd()
14005 
 
14006 
  def write(self, oprot):
14007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14009 
      return
14010 
    oprot.writeStructBegin('markAlertsAsSeen_args')
14011 
    if self.warehouseId is not None:
14012 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14013 
      oprot.writeI64(self.warehouseId)
14014 
      oprot.writeFieldEnd()
14015 
    oprot.writeFieldStop()
14016 
    oprot.writeStructEnd()
14017 
 
14018 
  def validate(self):
14019 
    return
14020 
 
14021 
 
14022 
  def __repr__(self):
14023 
    L = ['%s=%r' % (key, value)
14024 
      for key, value in self.__dict__.iteritems()]
14025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14026 
 
14027 
  def __eq__(self, other):
14028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14029 
 
14030 
  def __ne__(self, other):
14031 
    return not (self == other)
14032 
 
14033 
class markAlertsAsSeen_result:
14034 
 
14035 
  thrift_spec = (
14036 
  )
14037 
 
14038 
  def read(self, iprot):
14039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14041 
      return
14042 
    iprot.readStructBegin()
14043 
    while True:
14044 
      (fname, ftype, fid) = iprot.readFieldBegin()
14045 
      if ftype == TType.STOP:
14046 
        break
14047 
      else:
14048 
        iprot.skip(ftype)
14049 
      iprot.readFieldEnd()
14050 
    iprot.readStructEnd()
14051 
 
14052 
  def write(self, oprot):
14053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14055 
      return
14056 
    oprot.writeStructBegin('markAlertsAsSeen_result')
14057 
    oprot.writeFieldStop()
14058 
    oprot.writeStructEnd()
14059 
 
14060 
  def validate(self):
14061 
    return
14062 
 
14063 
 
14064 
  def __repr__(self):
14065 
    L = ['%s=%r' % (key, value)
14066 
      for key, value in self.__dict__.iteritems()]
14067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14068 
 
14069 
  def __eq__(self, other):
14070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14071 
 
14072 
  def __ne__(self, other):
14073 
    return not (self == other)
14074 
 
3064 chandransh 14075 
class getValidOrderCount_args:
14076 
 
14077 
  thrift_spec = (
14078 
  )
14079 
 
14080 
  def read(self, iprot):
14081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14083 
      return
14084 
    iprot.readStructBegin()
14085 
    while True:
14086 
      (fname, ftype, fid) = iprot.readFieldBegin()
14087 
      if ftype == TType.STOP:
14088 
        break
14089 
      else:
14090 
        iprot.skip(ftype)
14091 
      iprot.readFieldEnd()
14092 
    iprot.readStructEnd()
14093 
 
14094 
  def write(self, oprot):
14095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14097 
      return
14098 
    oprot.writeStructBegin('getValidOrderCount_args')
14099 
    oprot.writeFieldStop()
14100 
    oprot.writeStructEnd()
14101 
 
3431 rajveer 14102 
  def validate(self):
14103 
    return
14104 
 
14105 
 
3064 chandransh 14106 
  def __repr__(self):
14107 
    L = ['%s=%r' % (key, value)
14108 
      for key, value in self.__dict__.iteritems()]
14109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14110 
 
14111 
  def __eq__(self, other):
14112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14113 
 
14114 
  def __ne__(self, other):
14115 
    return not (self == other)
14116 
 
14117 
class getValidOrderCount_result:
94 ashish 14118 
  """
14119 
  Attributes:
14120 
   - success
14121 
  """
14122 
 
14123 
  thrift_spec = (
3064 chandransh 14124 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 14125 
  )
14126 
 
3064 chandransh 14127 
  def __init__(self, success=None,):
94 ashish 14128 
    self.success = success
14129 
 
14130 
  def read(self, iprot):
14131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14133 
      return
14134 
    iprot.readStructBegin()
14135 
    while True:
14136 
      (fname, ftype, fid) = iprot.readFieldBegin()
14137 
      if ftype == TType.STOP:
14138 
        break
14139 
      if fid == 0:
3064 chandransh 14140 
        if ftype == TType.I64:
14141 
          self.success = iprot.readI64();
94 ashish 14142 
        else:
14143 
          iprot.skip(ftype)
14144 
      else:
14145 
        iprot.skip(ftype)
14146 
      iprot.readFieldEnd()
14147 
    iprot.readStructEnd()
14148 
 
14149 
  def write(self, oprot):
14150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14152 
      return
3064 chandransh 14153 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 14154 
    if self.success is not None:
3064 chandransh 14155 
      oprot.writeFieldBegin('success', TType.I64, 0)
14156 
      oprot.writeI64(self.success)
94 ashish 14157 
      oprot.writeFieldEnd()
14158 
    oprot.writeFieldStop()
14159 
    oprot.writeStructEnd()
14160 
 
3431 rajveer 14161 
  def validate(self):
14162 
    return
14163 
 
14164 
 
94 ashish 14165 
  def __repr__(self):
14166 
    L = ['%s=%r' % (key, value)
14167 
      for key, value in self.__dict__.iteritems()]
14168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14169 
 
14170 
  def __eq__(self, other):
14171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14172 
 
14173 
  def __ne__(self, other):
14174 
    return not (self == other)
14175 
 
3064 chandransh 14176 
class getNoOfCustomersWithSuccessfulTransaction_args:
14177 
 
14178 
  thrift_spec = (
14179 
  )
14180 
 
14181 
  def read(self, iprot):
14182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14184 
      return
14185 
    iprot.readStructBegin()
14186 
    while True:
14187 
      (fname, ftype, fid) = iprot.readFieldBegin()
14188 
      if ftype == TType.STOP:
14189 
        break
14190 
      else:
14191 
        iprot.skip(ftype)
14192 
      iprot.readFieldEnd()
14193 
    iprot.readStructEnd()
14194 
 
14195 
  def write(self, oprot):
14196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14198 
      return
14199 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
14200 
    oprot.writeFieldStop()
14201 
    oprot.writeStructEnd()
14202 
 
3431 rajveer 14203 
  def validate(self):
14204 
    return
14205 
 
14206 
 
3064 chandransh 14207 
  def __repr__(self):
14208 
    L = ['%s=%r' % (key, value)
14209 
      for key, value in self.__dict__.iteritems()]
14210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14211 
 
14212 
  def __eq__(self, other):
14213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14214 
 
14215 
  def __ne__(self, other):
14216 
    return not (self == other)
14217 
 
14218 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 14219 
  """
14220 
  Attributes:
3064 chandransh 14221 
   - success
94 ashish 14222 
  """
14223 
 
14224 
  thrift_spec = (
3064 chandransh 14225 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 14226 
  )
14227 
 
3064 chandransh 14228 
  def __init__(self, success=None,):
14229 
    self.success = success
94 ashish 14230 
 
14231 
  def read(self, iprot):
14232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14234 
      return
14235 
    iprot.readStructBegin()
14236 
    while True:
14237 
      (fname, ftype, fid) = iprot.readFieldBegin()
14238 
      if ftype == TType.STOP:
14239 
        break
3064 chandransh 14240 
      if fid == 0:
94 ashish 14241 
        if ftype == TType.I64:
3064 chandransh 14242 
          self.success = iprot.readI64();
94 ashish 14243 
        else:
14244 
          iprot.skip(ftype)
14245 
      else:
14246 
        iprot.skip(ftype)
14247 
      iprot.readFieldEnd()
14248 
    iprot.readStructEnd()
14249 
 
14250 
  def write(self, oprot):
14251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14253 
      return
3064 chandransh 14254 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 14255 
    if self.success is not None:
3064 chandransh 14256 
      oprot.writeFieldBegin('success', TType.I64, 0)
14257 
      oprot.writeI64(self.success)
94 ashish 14258 
      oprot.writeFieldEnd()
14259 
    oprot.writeFieldStop()
14260 
    oprot.writeStructEnd()
14261 
 
3431 rajveer 14262 
  def validate(self):
14263 
    return
14264 
 
14265 
 
94 ashish 14266 
  def __repr__(self):
14267 
    L = ['%s=%r' % (key, value)
14268 
      for key, value in self.__dict__.iteritems()]
14269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14270 
 
14271 
  def __eq__(self, other):
14272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14273 
 
14274 
  def __ne__(self, other):
14275 
    return not (self == other)
14276 
 
3064 chandransh 14277 
class getValidOrdersAmountRange_args:
14278 
 
14279 
  thrift_spec = (
14280 
  )
14281 
 
14282 
  def read(self, iprot):
14283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14285 
      return
14286 
    iprot.readStructBegin()
14287 
    while True:
14288 
      (fname, ftype, fid) = iprot.readFieldBegin()
14289 
      if ftype == TType.STOP:
14290 
        break
14291 
      else:
14292 
        iprot.skip(ftype)
14293 
      iprot.readFieldEnd()
14294 
    iprot.readStructEnd()
14295 
 
14296 
  def write(self, oprot):
14297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14299 
      return
14300 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
14301 
    oprot.writeFieldStop()
14302 
    oprot.writeStructEnd()
14303 
 
3431 rajveer 14304 
  def validate(self):
14305 
    return
14306 
 
14307 
 
3064 chandransh 14308 
  def __repr__(self):
14309 
    L = ['%s=%r' % (key, value)
14310 
      for key, value in self.__dict__.iteritems()]
14311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14312 
 
14313 
  def __eq__(self, other):
14314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14315 
 
14316 
  def __ne__(self, other):
14317 
    return not (self == other)
14318 
 
14319 
class getValidOrdersAmountRange_result:
94 ashish 14320 
  """
14321 
  Attributes:
14322 
   - success
14323 
  """
14324 
 
14325 
  thrift_spec = (
3064 chandransh 14326 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 14327 
  )
14328 
 
3064 chandransh 14329 
  def __init__(self, success=None,):
94 ashish 14330 
    self.success = success
14331 
 
14332 
  def read(self, iprot):
14333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14335 
      return
14336 
    iprot.readStructBegin()
14337 
    while True:
14338 
      (fname, ftype, fid) = iprot.readFieldBegin()
14339 
      if ftype == TType.STOP:
14340 
        break
14341 
      if fid == 0:
483 rajveer 14342 
        if ftype == TType.LIST:
14343 
          self.success = []
6188 rajveer 14344 
          (_etype249, _size246) = iprot.readListBegin()
14345 
          for _i250 in xrange(_size246):
14346 
            _elem251 = iprot.readDouble();
14347 
            self.success.append(_elem251)
483 rajveer 14348 
          iprot.readListEnd()
94 ashish 14349 
        else:
14350 
          iprot.skip(ftype)
14351 
      else:
14352 
        iprot.skip(ftype)
14353 
      iprot.readFieldEnd()
14354 
    iprot.readStructEnd()
14355 
 
14356 
  def write(self, oprot):
14357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14359 
      return
3064 chandransh 14360 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 14361 
    if self.success is not None:
483 rajveer 14362 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 14363 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 14364 
      for iter252 in self.success:
14365 
        oprot.writeDouble(iter252)
483 rajveer 14366 
      oprot.writeListEnd()
94 ashish 14367 
      oprot.writeFieldEnd()
14368 
    oprot.writeFieldStop()
14369 
    oprot.writeStructEnd()
14370 
 
3431 rajveer 14371 
  def validate(self):
14372 
    return
14373 
 
14374 
 
94 ashish 14375 
  def __repr__(self):
14376 
    L = ['%s=%r' % (key, value)
14377 
      for key, value in self.__dict__.iteritems()]
14378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14379 
 
14380 
  def __eq__(self, other):
14381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14382 
 
14383 
  def __ne__(self, other):
14384 
    return not (self == other)
14385 
 
3064 chandransh 14386 
class getValidOrders_args:
1528 ankur.sing 14387 
  """
14388 
  Attributes:
3064 chandransh 14389 
   - limit
5874 rajveer 14390 
   - onlyStore
1528 ankur.sing 14391 
  """
14392 
 
14393 
  thrift_spec = (
14394 
    None, # 0
3064 chandransh 14395 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 14396 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 14397 
  )
14398 
 
5874 rajveer 14399 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 14400 
    self.limit = limit
5874 rajveer 14401 
    self.onlyStore = onlyStore
1528 ankur.sing 14402 
 
14403 
  def read(self, iprot):
14404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14406 
      return
14407 
    iprot.readStructBegin()
14408 
    while True:
14409 
      (fname, ftype, fid) = iprot.readFieldBegin()
14410 
      if ftype == TType.STOP:
14411 
        break
14412 
      if fid == 1:
14413 
        if ftype == TType.I64:
3064 chandransh 14414 
          self.limit = iprot.readI64();
1528 ankur.sing 14415 
        else:
14416 
          iprot.skip(ftype)
5874 rajveer 14417 
      elif fid == 2:
14418 
        if ftype == TType.BOOL:
14419 
          self.onlyStore = iprot.readBool();
14420 
        else:
14421 
          iprot.skip(ftype)
1528 ankur.sing 14422 
      else:
14423 
        iprot.skip(ftype)
14424 
      iprot.readFieldEnd()
14425 
    iprot.readStructEnd()
14426 
 
14427 
  def write(self, oprot):
14428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14430 
      return
3064 chandransh 14431 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 14432 
    if self.limit is not None:
3064 chandransh 14433 
      oprot.writeFieldBegin('limit', TType.I64, 1)
14434 
      oprot.writeI64(self.limit)
1528 ankur.sing 14435 
      oprot.writeFieldEnd()
5874 rajveer 14436 
    if self.onlyStore is not None:
14437 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
14438 
      oprot.writeBool(self.onlyStore)
14439 
      oprot.writeFieldEnd()
1528 ankur.sing 14440 
    oprot.writeFieldStop()
14441 
    oprot.writeStructEnd()
14442 
 
3431 rajveer 14443 
  def validate(self):
14444 
    return
14445 
 
14446 
 
1528 ankur.sing 14447 
  def __repr__(self):
14448 
    L = ['%s=%r' % (key, value)
14449 
      for key, value in self.__dict__.iteritems()]
14450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14451 
 
14452 
  def __eq__(self, other):
14453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14454 
 
14455 
  def __ne__(self, other):
14456 
    return not (self == other)
14457 
 
3064 chandransh 14458 
class getValidOrders_result:
1528 ankur.sing 14459 
  """
14460 
  Attributes:
14461 
   - success
14462 
  """
14463 
 
14464 
  thrift_spec = (
3064 chandransh 14465 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 14466 
  )
14467 
 
3064 chandransh 14468 
  def __init__(self, success=None,):
1528 ankur.sing 14469 
    self.success = success
14470 
 
14471 
  def read(self, iprot):
14472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14474 
      return
14475 
    iprot.readStructBegin()
14476 
    while True:
14477 
      (fname, ftype, fid) = iprot.readFieldBegin()
14478 
      if ftype == TType.STOP:
14479 
        break
14480 
      if fid == 0:
3064 chandransh 14481 
        if ftype == TType.LIST:
14482 
          self.success = []
6188 rajveer 14483 
          (_etype256, _size253) = iprot.readListBegin()
14484 
          for _i257 in xrange(_size253):
14485 
            _elem258 = Order()
14486 
            _elem258.read(iprot)
14487 
            self.success.append(_elem258)
3064 chandransh 14488 
          iprot.readListEnd()
1528 ankur.sing 14489 
        else:
14490 
          iprot.skip(ftype)
14491 
      else:
14492 
        iprot.skip(ftype)
14493 
      iprot.readFieldEnd()
14494 
    iprot.readStructEnd()
14495 
 
14496 
  def write(self, oprot):
14497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14499 
      return
3064 chandransh 14500 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 14501 
    if self.success is not None:
3064 chandransh 14502 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14503 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14504 
      for iter259 in self.success:
14505 
        iter259.write(oprot)
3064 chandransh 14506 
      oprot.writeListEnd()
1528 ankur.sing 14507 
      oprot.writeFieldEnd()
14508 
    oprot.writeFieldStop()
14509 
    oprot.writeStructEnd()
14510 
 
3431 rajveer 14511 
  def validate(self):
14512 
    return
14513 
 
14514 
 
1528 ankur.sing 14515 
  def __repr__(self):
14516 
    L = ['%s=%r' % (key, value)
14517 
      for key, value in self.__dict__.iteritems()]
14518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14519 
 
14520 
  def __eq__(self, other):
14521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14522 
 
14523 
  def __ne__(self, other):
14524 
    return not (self == other)
14525 
 
1220 chandransh 14526 
class batchOrders_args:
14527 
  """
14528 
  Attributes:
14529 
   - warehouseId
14530 
  """
14531 
 
14532 
  thrift_spec = (
14533 
    None, # 0
14534 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14535 
  )
14536 
 
14537 
  def __init__(self, warehouseId=None,):
14538 
    self.warehouseId = warehouseId
14539 
 
14540 
  def read(self, iprot):
14541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14543 
      return
14544 
    iprot.readStructBegin()
14545 
    while True:
14546 
      (fname, ftype, fid) = iprot.readFieldBegin()
14547 
      if ftype == TType.STOP:
14548 
        break
14549 
      if fid == 1:
14550 
        if ftype == TType.I64:
14551 
          self.warehouseId = iprot.readI64();
14552 
        else:
14553 
          iprot.skip(ftype)
14554 
      else:
14555 
        iprot.skip(ftype)
14556 
      iprot.readFieldEnd()
14557 
    iprot.readStructEnd()
14558 
 
14559 
  def write(self, oprot):
14560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14562 
      return
14563 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 14564 
    if self.warehouseId is not None:
1220 chandransh 14565 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14566 
      oprot.writeI64(self.warehouseId)
14567 
      oprot.writeFieldEnd()
14568 
    oprot.writeFieldStop()
14569 
    oprot.writeStructEnd()
14570 
 
3431 rajveer 14571 
  def validate(self):
14572 
    return
14573 
 
14574 
 
1220 chandransh 14575 
  def __repr__(self):
14576 
    L = ['%s=%r' % (key, value)
14577 
      for key, value in self.__dict__.iteritems()]
14578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14579 
 
14580 
  def __eq__(self, other):
14581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14582 
 
14583 
  def __ne__(self, other):
14584 
    return not (self == other)
14585 
 
14586 
class batchOrders_result:
14587 
  """
14588 
  Attributes:
14589 
   - success
14590 
   - ex
14591 
  """
14592 
 
14593 
  thrift_spec = (
14594 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14596 
  )
14597 
 
14598 
  def __init__(self, success=None, ex=None,):
14599 
    self.success = success
14600 
    self.ex = ex
14601 
 
14602 
  def read(self, iprot):
14603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14605 
      return
14606 
    iprot.readStructBegin()
14607 
    while True:
14608 
      (fname, ftype, fid) = iprot.readFieldBegin()
14609 
      if ftype == TType.STOP:
14610 
        break
14611 
      if fid == 0:
14612 
        if ftype == TType.LIST:
14613 
          self.success = []
6188 rajveer 14614 
          (_etype263, _size260) = iprot.readListBegin()
14615 
          for _i264 in xrange(_size260):
14616 
            _elem265 = Order()
14617 
            _elem265.read(iprot)
14618 
            self.success.append(_elem265)
1220 chandransh 14619 
          iprot.readListEnd()
14620 
        else:
14621 
          iprot.skip(ftype)
14622 
      elif fid == 1:
14623 
        if ftype == TType.STRUCT:
14624 
          self.ex = TransactionServiceException()
14625 
          self.ex.read(iprot)
14626 
        else:
14627 
          iprot.skip(ftype)
14628 
      else:
14629 
        iprot.skip(ftype)
14630 
      iprot.readFieldEnd()
14631 
    iprot.readStructEnd()
14632 
 
14633 
  def write(self, oprot):
14634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14636 
      return
14637 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 14638 
    if self.success is not None:
1220 chandransh 14639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14641 
      for iter266 in self.success:
14642 
        iter266.write(oprot)
1220 chandransh 14643 
      oprot.writeListEnd()
14644 
      oprot.writeFieldEnd()
3431 rajveer 14645 
    if self.ex is not None:
1220 chandransh 14646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14647 
      self.ex.write(oprot)
14648 
      oprot.writeFieldEnd()
14649 
    oprot.writeFieldStop()
14650 
    oprot.writeStructEnd()
14651 
 
3431 rajveer 14652 
  def validate(self):
14653 
    return
14654 
 
14655 
 
1220 chandransh 14656 
  def __repr__(self):
14657 
    L = ['%s=%r' % (key, value)
14658 
      for key, value in self.__dict__.iteritems()]
14659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14660 
 
14661 
  def __eq__(self, other):
14662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14663 
 
14664 
  def __ne__(self, other):
14665 
    return not (self == other)
14666 
 
1208 chandransh 14667 
class markOrderAsOutOfStock_args:
14668 
  """
14669 
  Attributes:
14670 
   - orderId
14671 
  """
14672 
 
14673 
  thrift_spec = (
14674 
    None, # 0
14675 
    (1, TType.I64, 'orderId', None, None, ), # 1
14676 
  )
14677 
 
14678 
  def __init__(self, orderId=None,):
14679 
    self.orderId = orderId
14680 
 
14681 
  def read(self, iprot):
14682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14684 
      return
14685 
    iprot.readStructBegin()
14686 
    while True:
14687 
      (fname, ftype, fid) = iprot.readFieldBegin()
14688 
      if ftype == TType.STOP:
14689 
        break
14690 
      if fid == 1:
14691 
        if ftype == TType.I64:
14692 
          self.orderId = iprot.readI64();
14693 
        else:
14694 
          iprot.skip(ftype)
14695 
      else:
14696 
        iprot.skip(ftype)
14697 
      iprot.readFieldEnd()
14698 
    iprot.readStructEnd()
14699 
 
14700 
  def write(self, oprot):
14701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14703 
      return
14704 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 14705 
    if self.orderId is not None:
1208 chandransh 14706 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14707 
      oprot.writeI64(self.orderId)
14708 
      oprot.writeFieldEnd()
14709 
    oprot.writeFieldStop()
14710 
    oprot.writeStructEnd()
14711 
 
3431 rajveer 14712 
  def validate(self):
14713 
    return
14714 
 
14715 
 
1208 chandransh 14716 
  def __repr__(self):
14717 
    L = ['%s=%r' % (key, value)
14718 
      for key, value in self.__dict__.iteritems()]
14719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14720 
 
14721 
  def __eq__(self, other):
14722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14723 
 
14724 
  def __ne__(self, other):
14725 
    return not (self == other)
14726 
 
14727 
class markOrderAsOutOfStock_result:
14728 
  """
14729 
  Attributes:
14730 
   - success
14731 
   - ex
14732 
  """
14733 
 
14734 
  thrift_spec = (
14735 
    (0, TType.BOOL, 'success', None, None, ), # 0
14736 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14737 
  )
14738 
 
14739 
  def __init__(self, success=None, ex=None,):
14740 
    self.success = success
14741 
    self.ex = ex
14742 
 
14743 
  def read(self, iprot):
14744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14746 
      return
14747 
    iprot.readStructBegin()
14748 
    while True:
14749 
      (fname, ftype, fid) = iprot.readFieldBegin()
14750 
      if ftype == TType.STOP:
14751 
        break
14752 
      if fid == 0:
14753 
        if ftype == TType.BOOL:
14754 
          self.success = iprot.readBool();
14755 
        else:
14756 
          iprot.skip(ftype)
14757 
      elif fid == 1:
14758 
        if ftype == TType.STRUCT:
14759 
          self.ex = TransactionServiceException()
14760 
          self.ex.read(iprot)
14761 
        else:
14762 
          iprot.skip(ftype)
14763 
      else:
14764 
        iprot.skip(ftype)
14765 
      iprot.readFieldEnd()
14766 
    iprot.readStructEnd()
14767 
 
14768 
  def write(self, oprot):
14769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14771 
      return
14772 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 14773 
    if self.success is not None:
1208 chandransh 14774 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14775 
      oprot.writeBool(self.success)
14776 
      oprot.writeFieldEnd()
3431 rajveer 14777 
    if self.ex is not None:
1208 chandransh 14778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14779 
      self.ex.write(oprot)
14780 
      oprot.writeFieldEnd()
14781 
    oprot.writeFieldStop()
14782 
    oprot.writeStructEnd()
14783 
 
3431 rajveer 14784 
  def validate(self):
14785 
    return
14786 
 
14787 
 
1208 chandransh 14788 
  def __repr__(self):
14789 
    L = ['%s=%r' % (key, value)
14790 
      for key, value in self.__dict__.iteritems()]
14791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14792 
 
14793 
  def __eq__(self, other):
14794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14795 
 
14796 
  def __ne__(self, other):
14797 
    return not (self == other)
14798 
 
3064 chandransh 14799 
class verifyOrder_args:
759 chandransh 14800 
  """
14801 
  Attributes:
3064 chandransh 14802 
   - orderId
759 chandransh 14803 
  """
14804 
 
14805 
  thrift_spec = (
14806 
    None, # 0
3064 chandransh 14807 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 14808 
  )
14809 
 
3064 chandransh 14810 
  def __init__(self, orderId=None,):
14811 
    self.orderId = orderId
759 chandransh 14812 
 
14813 
  def read(self, iprot):
14814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14816 
      return
14817 
    iprot.readStructBegin()
14818 
    while True:
14819 
      (fname, ftype, fid) = iprot.readFieldBegin()
14820 
      if ftype == TType.STOP:
14821 
        break
14822 
      if fid == 1:
14823 
        if ftype == TType.I64:
3064 chandransh 14824 
          self.orderId = iprot.readI64();
759 chandransh 14825 
        else:
14826 
          iprot.skip(ftype)
14827 
      else:
14828 
        iprot.skip(ftype)
14829 
      iprot.readFieldEnd()
14830 
    iprot.readStructEnd()
14831 
 
14832 
  def write(self, oprot):
14833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14835 
      return
3064 chandransh 14836 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14837 
    if self.orderId is not None:
3064 chandransh 14838 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14839 
      oprot.writeI64(self.orderId)
759 chandransh 14840 
      oprot.writeFieldEnd()
14841 
    oprot.writeFieldStop()
14842 
    oprot.writeStructEnd()
14843 
 
3431 rajveer 14844 
  def validate(self):
14845 
    return
14846 
 
14847 
 
759 chandransh 14848 
  def __repr__(self):
14849 
    L = ['%s=%r' % (key, value)
14850 
      for key, value in self.__dict__.iteritems()]
14851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14852 
 
14853 
  def __eq__(self, other):
14854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14855 
 
14856 
  def __ne__(self, other):
14857 
    return not (self == other)
14858 
 
3064 chandransh 14859 
class verifyOrder_result:
759 chandransh 14860 
  """
14861 
  Attributes:
14862 
   - success
14863 
   - ex
14864 
  """
14865 
 
14866 
  thrift_spec = (
14867 
    (0, TType.BOOL, 'success', None, None, ), # 0
14868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14869 
  )
14870 
 
14871 
  def __init__(self, success=None, ex=None,):
14872 
    self.success = success
14873 
    self.ex = ex
14874 
 
14875 
  def read(self, iprot):
14876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14878 
      return
14879 
    iprot.readStructBegin()
14880 
    while True:
14881 
      (fname, ftype, fid) = iprot.readFieldBegin()
14882 
      if ftype == TType.STOP:
14883 
        break
14884 
      if fid == 0:
14885 
        if ftype == TType.BOOL:
14886 
          self.success = iprot.readBool();
14887 
        else:
14888 
          iprot.skip(ftype)
14889 
      elif fid == 1:
14890 
        if ftype == TType.STRUCT:
14891 
          self.ex = TransactionServiceException()
14892 
          self.ex.read(iprot)
14893 
        else:
14894 
          iprot.skip(ftype)
14895 
      else:
14896 
        iprot.skip(ftype)
14897 
      iprot.readFieldEnd()
14898 
    iprot.readStructEnd()
14899 
 
14900 
  def write(self, oprot):
14901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14903 
      return
3064 chandransh 14904 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14905 
    if self.success is not None:
759 chandransh 14906 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14907 
      oprot.writeBool(self.success)
14908 
      oprot.writeFieldEnd()
3431 rajveer 14909 
    if self.ex is not None:
759 chandransh 14910 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14911 
      self.ex.write(oprot)
14912 
      oprot.writeFieldEnd()
14913 
    oprot.writeFieldStop()
14914 
    oprot.writeStructEnd()
14915 
 
3431 rajveer 14916 
  def validate(self):
14917 
    return
14918 
 
14919 
 
759 chandransh 14920 
  def __repr__(self):
14921 
    L = ['%s=%r' % (key, value)
14922 
      for key, value in self.__dict__.iteritems()]
14923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14924 
 
14925 
  def __eq__(self, other):
14926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14927 
 
14928 
  def __ne__(self, other):
14929 
    return not (self == other)
14930 
 
3064 chandransh 14931 
class acceptOrder_args:
1113 chandransh 14932 
  """
14933 
  Attributes:
3064 chandransh 14934 
   - orderId
1113 chandransh 14935 
  """
14936 
 
14937 
  thrift_spec = (
14938 
    None, # 0
3064 chandransh 14939 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14940 
  )
14941 
 
3064 chandransh 14942 
  def __init__(self, orderId=None,):
14943 
    self.orderId = orderId
1113 chandransh 14944 
 
14945 
  def read(self, iprot):
14946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14948 
      return
14949 
    iprot.readStructBegin()
14950 
    while True:
14951 
      (fname, ftype, fid) = iprot.readFieldBegin()
14952 
      if ftype == TType.STOP:
14953 
        break
14954 
      if fid == 1:
14955 
        if ftype == TType.I64:
3064 chandransh 14956 
          self.orderId = iprot.readI64();
1113 chandransh 14957 
        else:
14958 
          iprot.skip(ftype)
14959 
      else:
14960 
        iprot.skip(ftype)
14961 
      iprot.readFieldEnd()
14962 
    iprot.readStructEnd()
14963 
 
14964 
  def write(self, oprot):
14965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14967 
      return
3064 chandransh 14968 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14969 
    if self.orderId is not None:
3064 chandransh 14970 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14971 
      oprot.writeI64(self.orderId)
1113 chandransh 14972 
      oprot.writeFieldEnd()
14973 
    oprot.writeFieldStop()
14974 
    oprot.writeStructEnd()
14975 
 
3431 rajveer 14976 
  def validate(self):
14977 
    return
14978 
 
14979 
 
1113 chandransh 14980 
  def __repr__(self):
14981 
    L = ['%s=%r' % (key, value)
14982 
      for key, value in self.__dict__.iteritems()]
14983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14984 
 
14985 
  def __eq__(self, other):
14986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14987 
 
14988 
  def __ne__(self, other):
14989 
    return not (self == other)
14990 
 
3064 chandransh 14991 
class acceptOrder_result:
1113 chandransh 14992 
  """
14993 
  Attributes:
14994 
   - success
14995 
   - ex
14996 
  """
14997 
 
14998 
  thrift_spec = (
3064 chandransh 14999 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 15000 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15001 
  )
15002 
 
15003 
  def __init__(self, success=None, ex=None,):
15004 
    self.success = success
15005 
    self.ex = ex
15006 
 
15007 
  def read(self, iprot):
15008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15010 
      return
15011 
    iprot.readStructBegin()
15012 
    while True:
15013 
      (fname, ftype, fid) = iprot.readFieldBegin()
15014 
      if ftype == TType.STOP:
15015 
        break
15016 
      if fid == 0:
3064 chandransh 15017 
        if ftype == TType.BOOL:
15018 
          self.success = iprot.readBool();
1113 chandransh 15019 
        else:
15020 
          iprot.skip(ftype)
15021 
      elif fid == 1:
15022 
        if ftype == TType.STRUCT:
15023 
          self.ex = TransactionServiceException()
15024 
          self.ex.read(iprot)
15025 
        else:
15026 
          iprot.skip(ftype)
15027 
      else:
15028 
        iprot.skip(ftype)
15029 
      iprot.readFieldEnd()
15030 
    iprot.readStructEnd()
15031 
 
15032 
  def write(self, oprot):
15033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15035 
      return
3064 chandransh 15036 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 15037 
    if self.success is not None:
3064 chandransh 15038 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15039 
      oprot.writeBool(self.success)
1113 chandransh 15040 
      oprot.writeFieldEnd()
3431 rajveer 15041 
    if self.ex is not None:
1113 chandransh 15042 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15043 
      self.ex.write(oprot)
15044 
      oprot.writeFieldEnd()
15045 
    oprot.writeFieldStop()
15046 
    oprot.writeStructEnd()
15047 
 
3431 rajveer 15048 
  def validate(self):
15049 
    return
15050 
 
15051 
 
1113 chandransh 15052 
  def __repr__(self):
15053 
    L = ['%s=%r' % (key, value)
15054 
      for key, value in self.__dict__.iteritems()]
15055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15056 
 
15057 
  def __eq__(self, other):
15058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15059 
 
15060 
  def __ne__(self, other):
15061 
    return not (self == other)
15062 
 
3064 chandransh 15063 
class addBillingDetails_args:
1135 chandransh 15064 
  """
15065 
  Attributes:
3064 chandransh 15066 
   - orderId
15067 
   - invoice_number
4658 mandeep.dh 15068 
   - serialNumber
4283 anupam.sin 15069 
   - itemNumber
7190 amar.kumar 15070 
   - freebieWarehouseId
3064 chandransh 15071 
   - billed_by
4264 rajveer 15072 
   - jacketNumber
4283 anupam.sin 15073 
   - billingType
5110 mandeep.dh 15074 
   - fulfilmentWarehouseId
4763 rajveer 15075 
   - authorize
1135 chandransh 15076 
  """
15077 
 
15078 
  thrift_spec = (
15079 
    None, # 0
3064 chandransh 15080 
    (1, TType.I64, 'orderId', None, None, ), # 1
15081 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 15082 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
15083 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
7190 amar.kumar 15084 
    (5, TType.I64, 'freebieWarehouseId', None, None, ), # 5
15085 
    (6, TType.STRING, 'billed_by', None, None, ), # 6
15086 
    (7, TType.I64, 'jacketNumber', None, None, ), # 7
15087 
    (8, TType.I64, 'billingType', None, None, ), # 8
15088 
    (9, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 9
15089 
    (10, TType.BOOL, 'authorize', None, None, ), # 10
1135 chandransh 15090 
  )
15091 
 
7190 amar.kumar 15092 
  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 15093 
    self.orderId = orderId
15094 
    self.invoice_number = invoice_number
4658 mandeep.dh 15095 
    self.serialNumber = serialNumber
4283 anupam.sin 15096 
    self.itemNumber = itemNumber
7190 amar.kumar 15097 
    self.freebieWarehouseId = freebieWarehouseId
3064 chandransh 15098 
    self.billed_by = billed_by
4264 rajveer 15099 
    self.jacketNumber = jacketNumber
4283 anupam.sin 15100 
    self.billingType = billingType
5110 mandeep.dh 15101 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 15102 
    self.authorize = authorize
1135 chandransh 15103 
 
15104 
  def read(self, iprot):
15105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15107 
      return
15108 
    iprot.readStructBegin()
15109 
    while True:
15110 
      (fname, ftype, fid) = iprot.readFieldBegin()
15111 
      if ftype == TType.STOP:
15112 
        break
15113 
      if fid == 1:
15114 
        if ftype == TType.I64:
3064 chandransh 15115 
          self.orderId = iprot.readI64();
1135 chandransh 15116 
        else:
15117 
          iprot.skip(ftype)
15118 
      elif fid == 2:
3064 chandransh 15119 
        if ftype == TType.STRING:
15120 
          self.invoice_number = iprot.readString();
1135 chandransh 15121 
        else:
15122 
          iprot.skip(ftype)
3064 chandransh 15123 
      elif fid == 3:
5411 rajveer 15124 
        if ftype == TType.LIST:
15125 
          self.serialNumber = []
6188 rajveer 15126 
          (_etype270, _size267) = iprot.readListBegin()
15127 
          for _i271 in xrange(_size267):
15128 
            _elem272 = iprot.readString();
15129 
            self.serialNumber.append(_elem272)
5411 rajveer 15130 
          iprot.readListEnd()
3064 chandransh 15131 
        else:
15132 
          iprot.skip(ftype)
15133 
      elif fid == 4:
5411 rajveer 15134 
        if ftype == TType.LIST:
15135 
          self.itemNumber = []
6188 rajveer 15136 
          (_etype276, _size273) = iprot.readListBegin()
15137 
          for _i277 in xrange(_size273):
15138 
            _elem278 = iprot.readString();
15139 
            self.itemNumber.append(_elem278)
5411 rajveer 15140 
          iprot.readListEnd()
3064 chandransh 15141 
        else:
15142 
          iprot.skip(ftype)
15143 
      elif fid == 5:
7190 amar.kumar 15144 
        if ftype == TType.I64:
15145 
          self.freebieWarehouseId = iprot.readI64();
15146 
        else:
15147 
          iprot.skip(ftype)
15148 
      elif fid == 6:
3064 chandransh 15149 
        if ftype == TType.STRING:
4283 anupam.sin 15150 
          self.billed_by = iprot.readString();
3064 chandransh 15151 
        else:
15152 
          iprot.skip(ftype)
7190 amar.kumar 15153 
      elif fid == 7:
3064 chandransh 15154 
        if ftype == TType.I64:
4283 anupam.sin 15155 
          self.jacketNumber = iprot.readI64();
15156 
        else:
15157 
          iprot.skip(ftype)
7190 amar.kumar 15158 
      elif fid == 8:
4283 anupam.sin 15159 
        if ftype == TType.I64:
3064 chandransh 15160 
          self.billingType = iprot.readI64();
15161 
        else:
15162 
          iprot.skip(ftype)
7190 amar.kumar 15163 
      elif fid == 9:
4283 anupam.sin 15164 
        if ftype == TType.I64:
5110 mandeep.dh 15165 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 15166 
        else:
15167 
          iprot.skip(ftype)
7190 amar.kumar 15168 
      elif fid == 10:
4763 rajveer 15169 
        if ftype == TType.BOOL:
15170 
          self.authorize = iprot.readBool();
15171 
        else:
15172 
          iprot.skip(ftype)
1246 chandransh 15173 
      else:
15174 
        iprot.skip(ftype)
15175 
      iprot.readFieldEnd()
15176 
    iprot.readStructEnd()
15177 
 
15178 
  def write(self, oprot):
15179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15181 
      return
4283 anupam.sin 15182 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 15183 
    if self.orderId is not None:
3064 chandransh 15184 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15185 
      oprot.writeI64(self.orderId)
1246 chandransh 15186 
      oprot.writeFieldEnd()
4283 anupam.sin 15187 
    if self.invoice_number is not None:
15188 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
15189 
      oprot.writeString(self.invoice_number)
1246 chandransh 15190 
      oprot.writeFieldEnd()
4658 mandeep.dh 15191 
    if self.serialNumber is not None:
5411 rajveer 15192 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
15193 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 15194 
      for iter279 in self.serialNumber:
15195 
        oprot.writeString(iter279)
5411 rajveer 15196 
      oprot.writeListEnd()
3064 chandransh 15197 
      oprot.writeFieldEnd()
3431 rajveer 15198 
    if self.itemNumber is not None:
5411 rajveer 15199 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
15200 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 15201 
      for iter280 in self.itemNumber:
15202 
        oprot.writeString(iter280)
5411 rajveer 15203 
      oprot.writeListEnd()
3064 chandransh 15204 
      oprot.writeFieldEnd()
7190 amar.kumar 15205 
    if self.freebieWarehouseId is not None:
15206 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 5)
15207 
      oprot.writeI64(self.freebieWarehouseId)
15208 
      oprot.writeFieldEnd()
4283 anupam.sin 15209 
    if self.billed_by is not None:
7190 amar.kumar 15210 
      oprot.writeFieldBegin('billed_by', TType.STRING, 6)
4283 anupam.sin 15211 
      oprot.writeString(self.billed_by)
3064 chandransh 15212 
      oprot.writeFieldEnd()
4283 anupam.sin 15213 
    if self.jacketNumber is not None:
7190 amar.kumar 15214 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 7)
4283 anupam.sin 15215 
      oprot.writeI64(self.jacketNumber)
15216 
      oprot.writeFieldEnd()
3431 rajveer 15217 
    if self.billingType is not None:
7190 amar.kumar 15218 
      oprot.writeFieldBegin('billingType', TType.I64, 8)
3064 chandransh 15219 
      oprot.writeI64(self.billingType)
15220 
      oprot.writeFieldEnd()
5110 mandeep.dh 15221 
    if self.fulfilmentWarehouseId is not None:
7190 amar.kumar 15222 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 9)
5110 mandeep.dh 15223 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 15224 
      oprot.writeFieldEnd()
4763 rajveer 15225 
    if self.authorize is not None:
7190 amar.kumar 15226 
      oprot.writeFieldBegin('authorize', TType.BOOL, 10)
4763 rajveer 15227 
      oprot.writeBool(self.authorize)
15228 
      oprot.writeFieldEnd()
1246 chandransh 15229 
    oprot.writeFieldStop()
15230 
    oprot.writeStructEnd()
15231 
 
3431 rajveer 15232 
  def validate(self):
15233 
    return
15234 
 
15235 
 
1246 chandransh 15236 
  def __repr__(self):
15237 
    L = ['%s=%r' % (key, value)
15238 
      for key, value in self.__dict__.iteritems()]
15239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15240 
 
15241 
  def __eq__(self, other):
15242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15243 
 
15244 
  def __ne__(self, other):
15245 
    return not (self == other)
15246 
 
4283 anupam.sin 15247 
class addBillingDetails_result:
1246 chandransh 15248 
  """
15249 
  Attributes:
3064 chandransh 15250 
   - success
1246 chandransh 15251 
   - ex
15252 
  """
15253 
 
15254 
  thrift_spec = (
3064 chandransh 15255 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 15256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15257 
  )
15258 
 
3064 chandransh 15259 
  def __init__(self, success=None, ex=None,):
15260 
    self.success = success
1246 chandransh 15261 
    self.ex = ex
15262 
 
15263 
  def read(self, iprot):
15264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15266 
      return
15267 
    iprot.readStructBegin()
15268 
    while True:
15269 
      (fname, ftype, fid) = iprot.readFieldBegin()
15270 
      if ftype == TType.STOP:
15271 
        break
3064 chandransh 15272 
      if fid == 0:
15273 
        if ftype == TType.BOOL:
15274 
          self.success = iprot.readBool();
15275 
        else:
15276 
          iprot.skip(ftype)
15277 
      elif fid == 1:
1246 chandransh 15278 
        if ftype == TType.STRUCT:
15279 
          self.ex = TransactionServiceException()
15280 
          self.ex.read(iprot)
15281 
        else:
15282 
          iprot.skip(ftype)
15283 
      else:
15284 
        iprot.skip(ftype)
15285 
      iprot.readFieldEnd()
15286 
    iprot.readStructEnd()
15287 
 
15288 
  def write(self, oprot):
15289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15291 
      return
4283 anupam.sin 15292 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 15293 
    if self.success is not None:
3064 chandransh 15294 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15295 
      oprot.writeBool(self.success)
15296 
      oprot.writeFieldEnd()
3431 rajveer 15297 
    if self.ex is not None:
1246 chandransh 15298 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15299 
      self.ex.write(oprot)
15300 
      oprot.writeFieldEnd()
15301 
    oprot.writeFieldStop()
15302 
    oprot.writeStructEnd()
15303 
 
3431 rajveer 15304 
  def validate(self):
15305 
    return
15306 
 
15307 
 
1246 chandransh 15308 
  def __repr__(self):
15309 
    L = ['%s=%r' % (key, value)
15310 
      for key, value in self.__dict__.iteritems()]
15311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15312 
 
15313 
  def __eq__(self, other):
15314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15315 
 
15316 
  def __ne__(self, other):
15317 
    return not (self == other)
15318 
 
4579 rajveer 15319 
class addInvoiceNumber_args:
15320 
  """
15321 
  Attributes:
15322 
   - orderId
15323 
   - invoiceNumber
4763 rajveer 15324 
   - color
6756 amar.kumar 15325 
   - serialNumber
15326 
   - itemNumber
4579 rajveer 15327 
  """
15328 
 
15329 
  thrift_spec = (
15330 
    None, # 0
15331 
    (1, TType.I64, 'orderId', None, None, ), # 1
15332 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 15333 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 15334 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
15335 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 15336 
  )
15337 
 
6756 amar.kumar 15338 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 15339 
    self.orderId = orderId
15340 
    self.invoiceNumber = invoiceNumber
4763 rajveer 15341 
    self.color = color
6756 amar.kumar 15342 
    self.serialNumber = serialNumber
15343 
    self.itemNumber = itemNumber
4579 rajveer 15344 
 
15345 
  def read(self, iprot):
15346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15348 
      return
15349 
    iprot.readStructBegin()
15350 
    while True:
15351 
      (fname, ftype, fid) = iprot.readFieldBegin()
15352 
      if ftype == TType.STOP:
15353 
        break
15354 
      if fid == 1:
15355 
        if ftype == TType.I64:
15356 
          self.orderId = iprot.readI64();
15357 
        else:
15358 
          iprot.skip(ftype)
15359 
      elif fid == 2:
15360 
        if ftype == TType.STRING:
15361 
          self.invoiceNumber = iprot.readString();
15362 
        else:
15363 
          iprot.skip(ftype)
4763 rajveer 15364 
      elif fid == 3:
15365 
        if ftype == TType.STRING:
15366 
          self.color = iprot.readString();
15367 
        else:
15368 
          iprot.skip(ftype)
6756 amar.kumar 15369 
      elif fid == 4:
15370 
        if ftype == TType.STRING:
15371 
          self.serialNumber = iprot.readString();
15372 
        else:
15373 
          iprot.skip(ftype)
15374 
      elif fid == 5:
15375 
        if ftype == TType.STRING:
15376 
          self.itemNumber = iprot.readString();
15377 
        else:
15378 
          iprot.skip(ftype)
4579 rajveer 15379 
      else:
15380 
        iprot.skip(ftype)
15381 
      iprot.readFieldEnd()
15382 
    iprot.readStructEnd()
15383 
 
15384 
  def write(self, oprot):
15385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15387 
      return
15388 
    oprot.writeStructBegin('addInvoiceNumber_args')
15389 
    if self.orderId is not None:
15390 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15391 
      oprot.writeI64(self.orderId)
15392 
      oprot.writeFieldEnd()
15393 
    if self.invoiceNumber is not None:
15394 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
15395 
      oprot.writeString(self.invoiceNumber)
15396 
      oprot.writeFieldEnd()
4763 rajveer 15397 
    if self.color is not None:
15398 
      oprot.writeFieldBegin('color', TType.STRING, 3)
15399 
      oprot.writeString(self.color)
15400 
      oprot.writeFieldEnd()
6756 amar.kumar 15401 
    if self.serialNumber is not None:
15402 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
15403 
      oprot.writeString(self.serialNumber)
15404 
      oprot.writeFieldEnd()
15405 
    if self.itemNumber is not None:
15406 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
15407 
      oprot.writeString(self.itemNumber)
15408 
      oprot.writeFieldEnd()
4579 rajveer 15409 
    oprot.writeFieldStop()
15410 
    oprot.writeStructEnd()
15411 
 
15412 
  def validate(self):
15413 
    return
15414 
 
15415 
 
15416 
  def __repr__(self):
15417 
    L = ['%s=%r' % (key, value)
15418 
      for key, value in self.__dict__.iteritems()]
15419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15420 
 
15421 
  def __eq__(self, other):
15422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15423 
 
15424 
  def __ne__(self, other):
15425 
    return not (self == other)
15426 
 
15427 
class addInvoiceNumber_result:
15428 
  """
15429 
  Attributes:
15430 
   - ex
15431 
  """
15432 
 
15433 
  thrift_spec = (
15434 
    None, # 0
15435 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15436 
  )
15437 
 
15438 
  def __init__(self, ex=None,):
15439 
    self.ex = ex
15440 
 
15441 
  def read(self, iprot):
15442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15444 
      return
15445 
    iprot.readStructBegin()
15446 
    while True:
15447 
      (fname, ftype, fid) = iprot.readFieldBegin()
15448 
      if ftype == TType.STOP:
15449 
        break
15450 
      if fid == 1:
15451 
        if ftype == TType.STRUCT:
15452 
          self.ex = TransactionServiceException()
15453 
          self.ex.read(iprot)
15454 
        else:
15455 
          iprot.skip(ftype)
15456 
      else:
15457 
        iprot.skip(ftype)
15458 
      iprot.readFieldEnd()
15459 
    iprot.readStructEnd()
15460 
 
15461 
  def write(self, oprot):
15462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15464 
      return
15465 
    oprot.writeStructBegin('addInvoiceNumber_result')
15466 
    if self.ex is not None:
15467 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15468 
      self.ex.write(oprot)
15469 
      oprot.writeFieldEnd()
15470 
    oprot.writeFieldStop()
15471 
    oprot.writeStructEnd()
15472 
 
15473 
  def validate(self):
15474 
    return
15475 
 
15476 
 
15477 
  def __repr__(self):
15478 
    L = ['%s=%r' % (key, value)
15479 
      for key, value in self.__dict__.iteritems()]
15480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15481 
 
15482 
  def __eq__(self, other):
15483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15484 
 
15485 
  def __ne__(self, other):
15486 
    return not (self == other)
15487 
 
4910 phani.kuma 15488 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 15489 
  """
15490 
  Attributes:
3064 chandransh 15491 
   - warehouseId
1408 ankur.sing 15492 
   - providerId
3064 chandransh 15493 
   - cod
4910 phani.kuma 15494 
   - orderIds
1408 ankur.sing 15495 
  """
15496 
 
15497 
  thrift_spec = (
15498 
    None, # 0
3064 chandransh 15499 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15500 
    (2, TType.I64, 'providerId', None, None, ), # 2
15501 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 15502 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 15503 
  )
15504 
 
4910 phani.kuma 15505 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 15506 
    self.warehouseId = warehouseId
1408 ankur.sing 15507 
    self.providerId = providerId
3064 chandransh 15508 
    self.cod = cod
4910 phani.kuma 15509 
    self.orderIds = orderIds
1408 ankur.sing 15510 
 
15511 
  def read(self, iprot):
15512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15514 
      return
15515 
    iprot.readStructBegin()
15516 
    while True:
15517 
      (fname, ftype, fid) = iprot.readFieldBegin()
15518 
      if ftype == TType.STOP:
15519 
        break
15520 
      if fid == 1:
15521 
        if ftype == TType.I64:
3064 chandransh 15522 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 15523 
        else:
15524 
          iprot.skip(ftype)
15525 
      elif fid == 2:
15526 
        if ftype == TType.I64:
3064 chandransh 15527 
          self.providerId = iprot.readI64();
1408 ankur.sing 15528 
        else:
15529 
          iprot.skip(ftype)
3064 chandransh 15530 
      elif fid == 3:
15531 
        if ftype == TType.BOOL:
15532 
          self.cod = iprot.readBool();
15533 
        else:
15534 
          iprot.skip(ftype)
4910 phani.kuma 15535 
      elif fid == 4:
15536 
        if ftype == TType.LIST:
15537 
          self.orderIds = []
6188 rajveer 15538 
          (_etype284, _size281) = iprot.readListBegin()
15539 
          for _i285 in xrange(_size281):
15540 
            _elem286 = iprot.readI64();
15541 
            self.orderIds.append(_elem286)
4910 phani.kuma 15542 
          iprot.readListEnd()
15543 
        else:
15544 
          iprot.skip(ftype)
1408 ankur.sing 15545 
      else:
15546 
        iprot.skip(ftype)
15547 
      iprot.readFieldEnd()
15548 
    iprot.readStructEnd()
15549 
 
15550 
  def write(self, oprot):
15551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15553 
      return
4910 phani.kuma 15554 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 15555 
    if self.warehouseId is not None:
3064 chandransh 15556 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
15557 
      oprot.writeI64(self.warehouseId)
15558 
      oprot.writeFieldEnd()
3431 rajveer 15559 
    if self.providerId is not None:
3064 chandransh 15560 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 15561 
      oprot.writeI64(self.providerId)
15562 
      oprot.writeFieldEnd()
3431 rajveer 15563 
    if self.cod is not None:
3064 chandransh 15564 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
15565 
      oprot.writeBool(self.cod)
1408 ankur.sing 15566 
      oprot.writeFieldEnd()
4910 phani.kuma 15567 
    if self.orderIds is not None:
15568 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
15569 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15570 
      for iter287 in self.orderIds:
15571 
        oprot.writeI64(iter287)
4910 phani.kuma 15572 
      oprot.writeListEnd()
15573 
      oprot.writeFieldEnd()
1408 ankur.sing 15574 
    oprot.writeFieldStop()
15575 
    oprot.writeStructEnd()
15576 
 
3431 rajveer 15577 
  def validate(self):
15578 
    return
15579 
 
15580 
 
1408 ankur.sing 15581 
  def __repr__(self):
15582 
    L = ['%s=%r' % (key, value)
15583 
      for key, value in self.__dict__.iteritems()]
15584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15585 
 
15586 
  def __eq__(self, other):
15587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15588 
 
15589 
  def __ne__(self, other):
15590 
    return not (self == other)
15591 
 
4910 phani.kuma 15592 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 15593 
  """
15594 
  Attributes:
15595 
   - success
3064 chandransh 15596 
   - ex
1408 ankur.sing 15597 
  """
15598 
 
15599 
  thrift_spec = (
3064 chandransh 15600 
    (0, TType.BOOL, 'success', None, None, ), # 0
15601 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 15602 
  )
15603 
 
3064 chandransh 15604 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 15605 
    self.success = success
3064 chandransh 15606 
    self.ex = ex
1408 ankur.sing 15607 
 
15608 
  def read(self, iprot):
15609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15611 
      return
15612 
    iprot.readStructBegin()
15613 
    while True:
15614 
      (fname, ftype, fid) = iprot.readFieldBegin()
15615 
      if ftype == TType.STOP:
15616 
        break
15617 
      if fid == 0:
3064 chandransh 15618 
        if ftype == TType.BOOL:
15619 
          self.success = iprot.readBool();
1408 ankur.sing 15620 
        else:
15621 
          iprot.skip(ftype)
3064 chandransh 15622 
      elif fid == 1:
15623 
        if ftype == TType.STRUCT:
15624 
          self.ex = TransactionServiceException()
15625 
          self.ex.read(iprot)
15626 
        else:
15627 
          iprot.skip(ftype)
1408 ankur.sing 15628 
      else:
15629 
        iprot.skip(ftype)
15630 
      iprot.readFieldEnd()
15631 
    iprot.readStructEnd()
15632 
 
15633 
  def write(self, oprot):
15634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15636 
      return
4910 phani.kuma 15637 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 15638 
    if self.success is not None:
3064 chandransh 15639 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15640 
      oprot.writeBool(self.success)
1408 ankur.sing 15641 
      oprot.writeFieldEnd()
3431 rajveer 15642 
    if self.ex is not None:
3064 chandransh 15643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15644 
      self.ex.write(oprot)
15645 
      oprot.writeFieldEnd()
1408 ankur.sing 15646 
    oprot.writeFieldStop()
15647 
    oprot.writeStructEnd()
15648 
 
3431 rajveer 15649 
  def validate(self):
15650 
    return
15651 
 
15652 
 
1408 ankur.sing 15653 
  def __repr__(self):
15654 
    L = ['%s=%r' % (key, value)
15655 
      for key, value in self.__dict__.iteritems()]
15656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15657 
 
15658 
  def __eq__(self, other):
15659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15660 
 
15661 
  def __ne__(self, other):
15662 
    return not (self == other)
15663 
 
5676 rajveer 15664 
class markOrdersAsReturnedFromStore_args:
15665 
  """
15666 
  Attributes:
15667 
   - providerId
15668 
   - orderIds
5713 rajveer 15669 
   - awbs
5676 rajveer 15670 
  """
15671 
 
15672 
  thrift_spec = (
15673 
    None, # 0
15674 
    (1, TType.I64, 'providerId', None, None, ), # 1
15675 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 15676 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 15677 
  )
15678 
 
5713 rajveer 15679 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 15680 
    self.providerId = providerId
15681 
    self.orderIds = orderIds
5713 rajveer 15682 
    self.awbs = awbs
5676 rajveer 15683 
 
15684 
  def read(self, iprot):
15685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15687 
      return
15688 
    iprot.readStructBegin()
15689 
    while True:
15690 
      (fname, ftype, fid) = iprot.readFieldBegin()
15691 
      if ftype == TType.STOP:
15692 
        break
15693 
      if fid == 1:
15694 
        if ftype == TType.I64:
15695 
          self.providerId = iprot.readI64();
15696 
        else:
15697 
          iprot.skip(ftype)
15698 
      elif fid == 2:
15699 
        if ftype == TType.LIST:
15700 
          self.orderIds = []
6188 rajveer 15701 
          (_etype291, _size288) = iprot.readListBegin()
15702 
          for _i292 in xrange(_size288):
15703 
            _elem293 = iprot.readI64();
15704 
            self.orderIds.append(_elem293)
5676 rajveer 15705 
          iprot.readListEnd()
15706 
        else:
15707 
          iprot.skip(ftype)
5713 rajveer 15708 
      elif fid == 3:
15709 
        if ftype == TType.LIST:
15710 
          self.awbs = []
6188 rajveer 15711 
          (_etype297, _size294) = iprot.readListBegin()
15712 
          for _i298 in xrange(_size294):
15713 
            _elem299 = iprot.readString();
15714 
            self.awbs.append(_elem299)
5713 rajveer 15715 
          iprot.readListEnd()
15716 
        else:
15717 
          iprot.skip(ftype)
5676 rajveer 15718 
      else:
15719 
        iprot.skip(ftype)
15720 
      iprot.readFieldEnd()
15721 
    iprot.readStructEnd()
15722 
 
15723 
  def write(self, oprot):
15724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15726 
      return
15727 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
15728 
    if self.providerId is not None:
15729 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15730 
      oprot.writeI64(self.providerId)
15731 
      oprot.writeFieldEnd()
15732 
    if self.orderIds is not None:
15733 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
15734 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15735 
      for iter300 in self.orderIds:
15736 
        oprot.writeI64(iter300)
5676 rajveer 15737 
      oprot.writeListEnd()
15738 
      oprot.writeFieldEnd()
5713 rajveer 15739 
    if self.awbs is not None:
15740 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
15741 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 15742 
      for iter301 in self.awbs:
15743 
        oprot.writeString(iter301)
5713 rajveer 15744 
      oprot.writeListEnd()
15745 
      oprot.writeFieldEnd()
5676 rajveer 15746 
    oprot.writeFieldStop()
15747 
    oprot.writeStructEnd()
15748 
 
15749 
  def validate(self):
15750 
    return
15751 
 
15752 
 
15753 
  def __repr__(self):
15754 
    L = ['%s=%r' % (key, value)
15755 
      for key, value in self.__dict__.iteritems()]
15756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15757 
 
15758 
  def __eq__(self, other):
15759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15760 
 
15761 
  def __ne__(self, other):
15762 
    return not (self == other)
15763 
 
15764 
class markOrdersAsReturnedFromStore_result:
15765 
  """
15766 
  Attributes:
15767 
   - success
15768 
   - ex
15769 
  """
15770 
 
15771 
  thrift_spec = (
15772 
    (0, TType.BOOL, 'success', None, None, ), # 0
15773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15774 
  )
15775 
 
15776 
  def __init__(self, success=None, ex=None,):
15777 
    self.success = success
15778 
    self.ex = ex
15779 
 
15780 
  def read(self, iprot):
15781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15783 
      return
15784 
    iprot.readStructBegin()
15785 
    while True:
15786 
      (fname, ftype, fid) = iprot.readFieldBegin()
15787 
      if ftype == TType.STOP:
15788 
        break
15789 
      if fid == 0:
15790 
        if ftype == TType.BOOL:
15791 
          self.success = iprot.readBool();
15792 
        else:
15793 
          iprot.skip(ftype)
15794 
      elif fid == 1:
15795 
        if ftype == TType.STRUCT:
15796 
          self.ex = TransactionServiceException()
15797 
          self.ex.read(iprot)
15798 
        else:
15799 
          iprot.skip(ftype)
15800 
      else:
15801 
        iprot.skip(ftype)
15802 
      iprot.readFieldEnd()
15803 
    iprot.readStructEnd()
15804 
 
15805 
  def write(self, oprot):
15806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15808 
      return
15809 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
15810 
    if self.success is not None:
15811 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15812 
      oprot.writeBool(self.success)
15813 
      oprot.writeFieldEnd()
15814 
    if self.ex is not None:
15815 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15816 
      self.ex.write(oprot)
15817 
      oprot.writeFieldEnd()
15818 
    oprot.writeFieldStop()
15819 
    oprot.writeStructEnd()
15820 
 
15821 
  def validate(self):
15822 
    return
15823 
 
15824 
 
15825 
  def __repr__(self):
15826 
    L = ['%s=%r' % (key, value)
15827 
      for key, value in self.__dict__.iteritems()]
15828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15829 
 
15830 
  def __eq__(self, other):
15831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15832 
 
15833 
  def __ne__(self, other):
15834 
    return not (self == other)
15835 
 
4910 phani.kuma 15836 
class markOrdersAsPickedUp_args:
4410 rajveer 15837 
  """
15838 
  Attributes:
15839 
   - providerId
4910 phani.kuma 15840 
   - pickupDetails
4410 rajveer 15841 
  """
15842 
 
15843 
  thrift_spec = (
15844 
    None, # 0
4910 phani.kuma 15845 
    (1, TType.I64, 'providerId', None, None, ), # 1
15846 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15847 
  )
15848 
 
4910 phani.kuma 15849 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15850 
    self.providerId = providerId
4910 phani.kuma 15851 
    self.pickupDetails = pickupDetails
4410 rajveer 15852 
 
15853 
  def read(self, iprot):
15854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15856 
      return
15857 
    iprot.readStructBegin()
15858 
    while True:
15859 
      (fname, ftype, fid) = iprot.readFieldBegin()
15860 
      if ftype == TType.STOP:
15861 
        break
15862 
      if fid == 1:
15863 
        if ftype == TType.I64:
4910 phani.kuma 15864 
          self.providerId = iprot.readI64();
4410 rajveer 15865 
        else:
15866 
          iprot.skip(ftype)
15867 
      elif fid == 2:
4910 phani.kuma 15868 
        if ftype == TType.MAP:
15869 
          self.pickupDetails = {}
6188 rajveer 15870 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15871 
          for _i306 in xrange(_size302):
15872 
            _key307 = iprot.readString();
15873 
            _val308 = iprot.readString();
15874 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15875 
          iprot.readMapEnd()
4410 rajveer 15876 
        else:
15877 
          iprot.skip(ftype)
15878 
      else:
15879 
        iprot.skip(ftype)
15880 
      iprot.readFieldEnd()
15881 
    iprot.readStructEnd()
15882 
 
15883 
  def write(self, oprot):
15884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15886 
      return
4910 phani.kuma 15887 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15888 
    if self.providerId is not None:
4910 phani.kuma 15889 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15890 
      oprot.writeI64(self.providerId)
15891 
      oprot.writeFieldEnd()
4910 phani.kuma 15892 
    if self.pickupDetails is not None:
15893 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15894 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15895 
      for kiter309,viter310 in self.pickupDetails.items():
15896 
        oprot.writeString(kiter309)
15897 
        oprot.writeString(viter310)
4910 phani.kuma 15898 
      oprot.writeMapEnd()
4410 rajveer 15899 
      oprot.writeFieldEnd()
15900 
    oprot.writeFieldStop()
15901 
    oprot.writeStructEnd()
15902 
 
15903 
  def validate(self):
15904 
    return
15905 
 
15906 
 
15907 
  def __repr__(self):
15908 
    L = ['%s=%r' % (key, value)
15909 
      for key, value in self.__dict__.iteritems()]
15910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15911 
 
15912 
  def __eq__(self, other):
15913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15914 
 
15915 
  def __ne__(self, other):
15916 
    return not (self == other)
15917 
 
4910 phani.kuma 15918 
class markOrdersAsPickedUp_result:
4410 rajveer 15919 
  """
15920 
  Attributes:
15921 
   - ex
15922 
  """
15923 
 
15924 
  thrift_spec = (
4910 phani.kuma 15925 
    None, # 0
4410 rajveer 15926 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15927 
  )
15928 
 
4910 phani.kuma 15929 
  def __init__(self, ex=None,):
4410 rajveer 15930 
    self.ex = ex
15931 
 
15932 
  def read(self, iprot):
15933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15935 
      return
15936 
    iprot.readStructBegin()
15937 
    while True:
15938 
      (fname, ftype, fid) = iprot.readFieldBegin()
15939 
      if ftype == TType.STOP:
15940 
        break
4910 phani.kuma 15941 
      if fid == 1:
4410 rajveer 15942 
        if ftype == TType.STRUCT:
15943 
          self.ex = TransactionServiceException()
15944 
          self.ex.read(iprot)
15945 
        else:
15946 
          iprot.skip(ftype)
15947 
      else:
15948 
        iprot.skip(ftype)
15949 
      iprot.readFieldEnd()
15950 
    iprot.readStructEnd()
15951 
 
15952 
  def write(self, oprot):
15953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15955 
      return
4910 phani.kuma 15956 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15957 
    if self.ex is not None:
15958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15959 
      self.ex.write(oprot)
15960 
      oprot.writeFieldEnd()
15961 
    oprot.writeFieldStop()
15962 
    oprot.writeStructEnd()
15963 
 
15964 
  def validate(self):
15965 
    return
15966 
 
15967 
 
15968 
  def __repr__(self):
15969 
    L = ['%s=%r' % (key, value)
15970 
      for key, value in self.__dict__.iteritems()]
15971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15972 
 
15973 
  def __eq__(self, other):
15974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15975 
 
15976 
  def __ne__(self, other):
15977 
    return not (self == other)
15978 
 
4910 phani.kuma 15979 
class getOrdersNotPickedUp_args:
304 ashish 15980 
  """
15981 
  Attributes:
3064 chandransh 15982 
   - providerId
304 ashish 15983 
  """
94 ashish 15984 
 
304 ashish 15985 
  thrift_spec = (
15986 
    None, # 0
3064 chandransh 15987 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15988 
  )
15989 
 
4910 phani.kuma 15990 
  def __init__(self, providerId=None,):
3064 chandransh 15991 
    self.providerId = providerId
304 ashish 15992 
 
15993 
  def read(self, iprot):
15994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15996 
      return
15997 
    iprot.readStructBegin()
15998 
    while True:
15999 
      (fname, ftype, fid) = iprot.readFieldBegin()
16000 
      if ftype == TType.STOP:
16001 
        break
16002 
      if fid == 1:
16003 
        if ftype == TType.I64:
3064 chandransh 16004 
          self.providerId = iprot.readI64();
304 ashish 16005 
        else:
16006 
          iprot.skip(ftype)
16007 
      else:
16008 
        iprot.skip(ftype)
16009 
      iprot.readFieldEnd()
16010 
    iprot.readStructEnd()
16011 
 
16012 
  def write(self, oprot):
16013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16015 
      return
4910 phani.kuma 16016 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 16017 
    if self.providerId is not None:
3064 chandransh 16018 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16019 
      oprot.writeI64(self.providerId)
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 
 
4910 phani.kuma 16039 
class getOrdersNotPickedUp_result:
304 ashish 16040 
  """
16041 
  Attributes:
16042 
   - success
16043 
  """
16044 
 
16045 
  thrift_spec = (
3064 chandransh 16046 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 16047 
  )
16048 
 
4910 phani.kuma 16049 
  def __init__(self, success=None,):
304 ashish 16050 
    self.success = success
16051 
 
16052 
  def read(self, iprot):
16053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16055 
      return
16056 
    iprot.readStructBegin()
16057 
    while True:
16058 
      (fname, ftype, fid) = iprot.readFieldBegin()
16059 
      if ftype == TType.STOP:
16060 
        break
16061 
      if fid == 0:
16062 
        if ftype == TType.LIST:
16063 
          self.success = []
6188 rajveer 16064 
          (_etype314, _size311) = iprot.readListBegin()
16065 
          for _i315 in xrange(_size311):
16066 
            _elem316 = Order()
16067 
            _elem316.read(iprot)
16068 
            self.success.append(_elem316)
304 ashish 16069 
          iprot.readListEnd()
16070 
        else:
16071 
          iprot.skip(ftype)
16072 
      else:
16073 
        iprot.skip(ftype)
16074 
      iprot.readFieldEnd()
16075 
    iprot.readStructEnd()
16076 
 
16077 
  def write(self, oprot):
16078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16080 
      return
4910 phani.kuma 16081 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 16082 
    if self.success is not None:
304 ashish 16083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16085 
      for iter317 in self.success:
16086 
        iter317.write(oprot)
304 ashish 16087 
      oprot.writeListEnd()
16088 
      oprot.writeFieldEnd()
16089 
    oprot.writeFieldStop()
16090 
    oprot.writeStructEnd()
16091 
 
3431 rajveer 16092 
  def validate(self):
16093 
    return
16094 
 
16095 
 
304 ashish 16096 
  def __repr__(self):
16097 
    L = ['%s=%r' % (key, value)
16098 
      for key, value in self.__dict__.iteritems()]
16099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16100 
 
16101 
  def __eq__(self, other):
16102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16103 
 
16104 
  def __ne__(self, other):
16105 
    return not (self == other)
16106 
 
3064 chandransh 16107 
class markOrdersAsDelivered_args:
304 ashish 16108 
  """
16109 
  Attributes:
3064 chandransh 16110 
   - providerId
16111 
   - deliveredOrders
304 ashish 16112 
  """
16113 
 
16114 
  thrift_spec = (
16115 
    None, # 0
3064 chandransh 16116 
    (1, TType.I64, 'providerId', None, None, ), # 1
16117 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 16118 
  )
16119 
 
3064 chandransh 16120 
  def __init__(self, providerId=None, deliveredOrders=None,):
16121 
    self.providerId = providerId
16122 
    self.deliveredOrders = deliveredOrders
304 ashish 16123 
 
16124 
  def read(self, iprot):
16125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16127 
      return
16128 
    iprot.readStructBegin()
16129 
    while True:
16130 
      (fname, ftype, fid) = iprot.readFieldBegin()
16131 
      if ftype == TType.STOP:
16132 
        break
16133 
      if fid == 1:
16134 
        if ftype == TType.I64:
3064 chandransh 16135 
          self.providerId = iprot.readI64();
304 ashish 16136 
        else:
16137 
          iprot.skip(ftype)
16138 
      elif fid == 2:
3064 chandransh 16139 
        if ftype == TType.MAP:
16140 
          self.deliveredOrders = {}
6188 rajveer 16141 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
16142 
          for _i322 in xrange(_size318):
16143 
            _key323 = iprot.readString();
16144 
            _val324 = iprot.readString();
16145 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 16146 
          iprot.readMapEnd()
304 ashish 16147 
        else:
16148 
          iprot.skip(ftype)
16149 
      else:
16150 
        iprot.skip(ftype)
16151 
      iprot.readFieldEnd()
16152 
    iprot.readStructEnd()
16153 
 
16154 
  def write(self, oprot):
16155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16157 
      return
3064 chandransh 16158 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 16159 
    if self.providerId is not None:
3064 chandransh 16160 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16161 
      oprot.writeI64(self.providerId)
304 ashish 16162 
      oprot.writeFieldEnd()
3431 rajveer 16163 
    if self.deliveredOrders is not None:
3064 chandransh 16164 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
16165 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 16166 
      for kiter325,viter326 in self.deliveredOrders.items():
16167 
        oprot.writeString(kiter325)
16168 
        oprot.writeString(viter326)
3064 chandransh 16169 
      oprot.writeMapEnd()
304 ashish 16170 
      oprot.writeFieldEnd()
16171 
    oprot.writeFieldStop()
16172 
    oprot.writeStructEnd()
16173 
 
3431 rajveer 16174 
  def validate(self):
16175 
    return
16176 
 
16177 
 
304 ashish 16178 
  def __repr__(self):
16179 
    L = ['%s=%r' % (key, value)
16180 
      for key, value in self.__dict__.iteritems()]
16181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16182 
 
16183 
  def __eq__(self, other):
16184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16185 
 
16186 
  def __ne__(self, other):
16187 
    return not (self == other)
16188 
 
3064 chandransh 16189 
class markOrdersAsDelivered_result:
16190 
  """
16191 
  Attributes:
16192 
   - ex
16193 
  """
304 ashish 16194 
 
16195 
  thrift_spec = (
3064 chandransh 16196 
    None, # 0
16197 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 16198 
  )
16199 
 
3064 chandransh 16200 
  def __init__(self, ex=None,):
16201 
    self.ex = ex
304 ashish 16202 
 
1596 ankur.sing 16203 
  def read(self, iprot):
16204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16206 
      return
16207 
    iprot.readStructBegin()
16208 
    while True:
16209 
      (fname, ftype, fid) = iprot.readFieldBegin()
16210 
      if ftype == TType.STOP:
16211 
        break
3064 chandransh 16212 
      if fid == 1:
16213 
        if ftype == TType.STRUCT:
16214 
          self.ex = TransactionServiceException()
16215 
          self.ex.read(iprot)
16216 
        else:
16217 
          iprot.skip(ftype)
1596 ankur.sing 16218 
      else:
16219 
        iprot.skip(ftype)
16220 
      iprot.readFieldEnd()
16221 
    iprot.readStructEnd()
16222 
 
16223 
  def write(self, oprot):
16224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16226 
      return
3064 chandransh 16227 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 16228 
    if self.ex is not None:
3064 chandransh 16229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16230 
      self.ex.write(oprot)
16231 
      oprot.writeFieldEnd()
1596 ankur.sing 16232 
    oprot.writeFieldStop()
16233 
    oprot.writeStructEnd()
16234 
 
3431 rajveer 16235 
  def validate(self):
16236 
    return
16237 
 
16238 
 
1596 ankur.sing 16239 
  def __repr__(self):
16240 
    L = ['%s=%r' % (key, value)
16241 
      for key, value in self.__dict__.iteritems()]
16242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16243 
 
16244 
  def __eq__(self, other):
16245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16246 
 
16247 
  def __ne__(self, other):
16248 
    return not (self == other)
16249 
 
4910 phani.kuma 16250 
class markAsRTOrders_args:
1596 ankur.sing 16251 
  """
16252 
  Attributes:
3064 chandransh 16253 
   - providerId
16254 
   - returnedOrders
1596 ankur.sing 16255 
  """
16256 
 
16257 
  thrift_spec = (
3064 chandransh 16258 
    None, # 0
16259 
    (1, TType.I64, 'providerId', None, None, ), # 1
16260 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 16261 
  )
16262 
 
3064 chandransh 16263 
  def __init__(self, providerId=None, returnedOrders=None,):
16264 
    self.providerId = providerId
16265 
    self.returnedOrders = returnedOrders
1596 ankur.sing 16266 
 
16267 
  def read(self, iprot):
16268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16270 
      return
16271 
    iprot.readStructBegin()
16272 
    while True:
16273 
      (fname, ftype, fid) = iprot.readFieldBegin()
16274 
      if ftype == TType.STOP:
16275 
        break
3064 chandransh 16276 
      if fid == 1:
1596 ankur.sing 16277 
        if ftype == TType.I64:
3064 chandransh 16278 
          self.providerId = iprot.readI64();
1596 ankur.sing 16279 
        else:
16280 
          iprot.skip(ftype)
3064 chandransh 16281 
      elif fid == 2:
16282 
        if ftype == TType.MAP:
16283 
          self.returnedOrders = {}
6188 rajveer 16284 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
16285 
          for _i331 in xrange(_size327):
16286 
            _key332 = iprot.readString();
16287 
            _val333 = iprot.readString();
16288 
            self.returnedOrders[_key332] = _val333
3064 chandransh 16289 
          iprot.readMapEnd()
16290 
        else:
16291 
          iprot.skip(ftype)
1596 ankur.sing 16292 
      else:
16293 
        iprot.skip(ftype)
16294 
      iprot.readFieldEnd()
16295 
    iprot.readStructEnd()
16296 
 
16297 
  def write(self, oprot):
16298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16300 
      return
4910 phani.kuma 16301 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 16302 
    if self.providerId is not None:
3064 chandransh 16303 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16304 
      oprot.writeI64(self.providerId)
1596 ankur.sing 16305 
      oprot.writeFieldEnd()
3431 rajveer 16306 
    if self.returnedOrders is not None:
3064 chandransh 16307 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
16308 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 16309 
      for kiter334,viter335 in self.returnedOrders.items():
16310 
        oprot.writeString(kiter334)
16311 
        oprot.writeString(viter335)
3064 chandransh 16312 
      oprot.writeMapEnd()
16313 
      oprot.writeFieldEnd()
1596 ankur.sing 16314 
    oprot.writeFieldStop()
16315 
    oprot.writeStructEnd()
16316 
 
3431 rajveer 16317 
  def validate(self):
16318 
    return
16319 
 
16320 
 
1596 ankur.sing 16321 
  def __repr__(self):
16322 
    L = ['%s=%r' % (key, value)
16323 
      for key, value in self.__dict__.iteritems()]
16324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16325 
 
16326 
  def __eq__(self, other):
16327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16328 
 
16329 
  def __ne__(self, other):
16330 
    return not (self == other)
16331 
 
4910 phani.kuma 16332 
class markAsRTOrders_result:
3064 chandransh 16333 
  """
16334 
  Attributes:
16335 
   - ex
16336 
  """
1596 ankur.sing 16337 
 
1627 ankur.sing 16338 
  thrift_spec = (
3064 chandransh 16339 
    None, # 0
16340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 16341 
  )
16342 
 
3064 chandransh 16343 
  def __init__(self, ex=None,):
16344 
    self.ex = ex
16345 
 
1627 ankur.sing 16346 
  def read(self, iprot):
16347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16349 
      return
16350 
    iprot.readStructBegin()
16351 
    while True:
16352 
      (fname, ftype, fid) = iprot.readFieldBegin()
16353 
      if ftype == TType.STOP:
16354 
        break
3064 chandransh 16355 
      if fid == 1:
16356 
        if ftype == TType.STRUCT:
16357 
          self.ex = TransactionServiceException()
16358 
          self.ex.read(iprot)
16359 
        else:
16360 
          iprot.skip(ftype)
1627 ankur.sing 16361 
      else:
16362 
        iprot.skip(ftype)
16363 
      iprot.readFieldEnd()
16364 
    iprot.readStructEnd()
16365 
 
16366 
  def write(self, oprot):
16367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16369 
      return
4910 phani.kuma 16370 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 16371 
    if self.ex is not None:
3064 chandransh 16372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16373 
      self.ex.write(oprot)
16374 
      oprot.writeFieldEnd()
1627 ankur.sing 16375 
    oprot.writeFieldStop()
16376 
    oprot.writeStructEnd()
16377 
 
3431 rajveer 16378 
  def validate(self):
16379 
    return
16380 
 
16381 
 
1627 ankur.sing 16382 
  def __repr__(self):
16383 
    L = ['%s=%r' % (key, value)
16384 
      for key, value in self.__dict__.iteritems()]
16385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16386 
 
16387 
  def __eq__(self, other):
16388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16389 
 
16390 
  def __ne__(self, other):
16391 
    return not (self == other)
16392 
 
4910 phani.kuma 16393 
class getRTOrders_args:
16394 
  """
16395 
  Attributes:
16396 
   - providerId
16397 
  """
16398 
 
16399 
  thrift_spec = (
16400 
    None, # 0
16401 
    (1, TType.I64, 'providerId', None, None, ), # 1
16402 
  )
16403 
 
16404 
  def __init__(self, providerId=None,):
16405 
    self.providerId = providerId
16406 
 
16407 
  def read(self, iprot):
16408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16410 
      return
16411 
    iprot.readStructBegin()
16412 
    while True:
16413 
      (fname, ftype, fid) = iprot.readFieldBegin()
16414 
      if ftype == TType.STOP:
16415 
        break
16416 
      if fid == 1:
16417 
        if ftype == TType.I64:
16418 
          self.providerId = iprot.readI64();
16419 
        else:
16420 
          iprot.skip(ftype)
16421 
      else:
16422 
        iprot.skip(ftype)
16423 
      iprot.readFieldEnd()
16424 
    iprot.readStructEnd()
16425 
 
16426 
  def write(self, oprot):
16427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16429 
      return
16430 
    oprot.writeStructBegin('getRTOrders_args')
16431 
    if self.providerId is not None:
16432 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16433 
      oprot.writeI64(self.providerId)
16434 
      oprot.writeFieldEnd()
16435 
    oprot.writeFieldStop()
16436 
    oprot.writeStructEnd()
16437 
 
16438 
  def validate(self):
16439 
    return
16440 
 
16441 
 
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 
 
16453 
class getRTOrders_result:
16454 
  """
16455 
  Attributes:
16456 
   - success
16457 
  """
16458 
 
16459 
  thrift_spec = (
16460 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16461 
  )
16462 
 
16463 
  def __init__(self, success=None,):
16464 
    self.success = success
16465 
 
16466 
  def read(self, iprot):
16467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16469 
      return
16470 
    iprot.readStructBegin()
16471 
    while True:
16472 
      (fname, ftype, fid) = iprot.readFieldBegin()
16473 
      if ftype == TType.STOP:
16474 
        break
16475 
      if fid == 0:
16476 
        if ftype == TType.LIST:
16477 
          self.success = []
6188 rajveer 16478 
          (_etype339, _size336) = iprot.readListBegin()
16479 
          for _i340 in xrange(_size336):
16480 
            _elem341 = Order()
16481 
            _elem341.read(iprot)
16482 
            self.success.append(_elem341)
4910 phani.kuma 16483 
          iprot.readListEnd()
16484 
        else:
16485 
          iprot.skip(ftype)
16486 
      else:
16487 
        iprot.skip(ftype)
16488 
      iprot.readFieldEnd()
16489 
    iprot.readStructEnd()
16490 
 
16491 
  def write(self, oprot):
16492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16494 
      return
16495 
    oprot.writeStructBegin('getRTOrders_result')
16496 
    if self.success is not None:
16497 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16498 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16499 
      for iter342 in self.success:
16500 
        iter342.write(oprot)
4910 phani.kuma 16501 
      oprot.writeListEnd()
16502 
      oprot.writeFieldEnd()
16503 
    oprot.writeFieldStop()
16504 
    oprot.writeStructEnd()
16505 
 
16506 
  def validate(self):
16507 
    return
16508 
 
16509 
 
16510 
  def __repr__(self):
16511 
    L = ['%s=%r' % (key, value)
16512 
      for key, value in self.__dict__.iteritems()]
16513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16514 
 
16515 
  def __eq__(self, other):
16516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16517 
 
16518 
  def __ne__(self, other):
16519 
    return not (self == other)
16520 
 
3064 chandransh 16521 
class updateNonDeliveryReason_args:
1627 ankur.sing 16522 
  """
16523 
  Attributes:
3064 chandransh 16524 
   - providerId
16525 
   - undeliveredOrders
1627 ankur.sing 16526 
  """
16527 
 
16528 
  thrift_spec = (
3064 chandransh 16529 
    None, # 0
16530 
    (1, TType.I64, 'providerId', None, None, ), # 1
16531 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 16532 
  )
16533 
 
3064 chandransh 16534 
  def __init__(self, providerId=None, undeliveredOrders=None,):
16535 
    self.providerId = providerId
16536 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 16537 
 
16538 
  def read(self, iprot):
16539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16541 
      return
16542 
    iprot.readStructBegin()
16543 
    while True:
16544 
      (fname, ftype, fid) = iprot.readFieldBegin()
16545 
      if ftype == TType.STOP:
16546 
        break
3064 chandransh 16547 
      if fid == 1:
1627 ankur.sing 16548 
        if ftype == TType.I64:
3064 chandransh 16549 
          self.providerId = iprot.readI64();
1627 ankur.sing 16550 
        else:
16551 
          iprot.skip(ftype)
3064 chandransh 16552 
      elif fid == 2:
16553 
        if ftype == TType.MAP:
16554 
          self.undeliveredOrders = {}
6188 rajveer 16555 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
16556 
          for _i347 in xrange(_size343):
16557 
            _key348 = iprot.readString();
16558 
            _val349 = iprot.readString();
16559 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 16560 
          iprot.readMapEnd()
16561 
        else:
16562 
          iprot.skip(ftype)
1627 ankur.sing 16563 
      else:
16564 
        iprot.skip(ftype)
16565 
      iprot.readFieldEnd()
16566 
    iprot.readStructEnd()
16567 
 
16568 
  def write(self, oprot):
16569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16571 
      return
3064 chandransh 16572 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 16573 
    if self.providerId is not None:
3064 chandransh 16574 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16575 
      oprot.writeI64(self.providerId)
1627 ankur.sing 16576 
      oprot.writeFieldEnd()
3431 rajveer 16577 
    if self.undeliveredOrders is not None:
3064 chandransh 16578 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
16579 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 16580 
      for kiter350,viter351 in self.undeliveredOrders.items():
16581 
        oprot.writeString(kiter350)
16582 
        oprot.writeString(viter351)
3064 chandransh 16583 
      oprot.writeMapEnd()
16584 
      oprot.writeFieldEnd()
1627 ankur.sing 16585 
    oprot.writeFieldStop()
16586 
    oprot.writeStructEnd()
16587 
 
3431 rajveer 16588 
  def validate(self):
16589 
    return
16590 
 
16591 
 
1627 ankur.sing 16592 
  def __repr__(self):
16593 
    L = ['%s=%r' % (key, value)
16594 
      for key, value in self.__dict__.iteritems()]
16595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16596 
 
16597 
  def __eq__(self, other):
16598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16599 
 
16600 
  def __ne__(self, other):
16601 
    return not (self == other)
16602 
 
3064 chandransh 16603 
class updateNonDeliveryReason_result:
1627 ankur.sing 16604 
  """
16605 
  Attributes:
3064 chandransh 16606 
   - ex
1627 ankur.sing 16607 
  """
16608 
 
16609 
  thrift_spec = (
4910 phani.kuma 16610 
    None, # 0
3064 chandransh 16611 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 16612 
  )
16613 
 
4910 phani.kuma 16614 
  def __init__(self, ex=None,):
3064 chandransh 16615 
    self.ex = ex
1627 ankur.sing 16616 
 
16617 
  def read(self, iprot):
16618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16620 
      return
16621 
    iprot.readStructBegin()
16622 
    while True:
16623 
      (fname, ftype, fid) = iprot.readFieldBegin()
16624 
      if ftype == TType.STOP:
16625 
        break
4910 phani.kuma 16626 
      if fid == 1:
16627 
        if ftype == TType.STRUCT:
16628 
          self.ex = TransactionServiceException()
16629 
          self.ex.read(iprot)
16630 
        else:
16631 
          iprot.skip(ftype)
16632 
      else:
16633 
        iprot.skip(ftype)
16634 
      iprot.readFieldEnd()
16635 
    iprot.readStructEnd()
16636 
 
16637 
  def write(self, oprot):
16638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16640 
      return
16641 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
16642 
    if self.ex is not None:
16643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16644 
      self.ex.write(oprot)
16645 
      oprot.writeFieldEnd()
16646 
    oprot.writeFieldStop()
16647 
    oprot.writeStructEnd()
16648 
 
16649 
  def validate(self):
16650 
    return
16651 
 
16652 
 
16653 
  def __repr__(self):
16654 
    L = ['%s=%r' % (key, value)
16655 
      for key, value in self.__dict__.iteritems()]
16656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16657 
 
16658 
  def __eq__(self, other):
16659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16660 
 
16661 
  def __ne__(self, other):
16662 
    return not (self == other)
16663 
 
16664 
class getNonDeliveredOrdersbyCourier_args:
16665 
  """
16666 
  Attributes:
16667 
   - providerId
16668 
  """
16669 
 
16670 
  thrift_spec = (
16671 
    None, # 0
16672 
    (1, TType.I64, 'providerId', None, None, ), # 1
16673 
  )
16674 
 
16675 
  def __init__(self, providerId=None,):
16676 
    self.providerId = providerId
16677 
 
16678 
  def read(self, iprot):
16679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16681 
      return
16682 
    iprot.readStructBegin()
16683 
    while True:
16684 
      (fname, ftype, fid) = iprot.readFieldBegin()
16685 
      if ftype == TType.STOP:
16686 
        break
16687 
      if fid == 1:
16688 
        if ftype == TType.I64:
16689 
          self.providerId = iprot.readI64();
16690 
        else:
16691 
          iprot.skip(ftype)
16692 
      else:
16693 
        iprot.skip(ftype)
16694 
      iprot.readFieldEnd()
16695 
    iprot.readStructEnd()
16696 
 
16697 
  def write(self, oprot):
16698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16700 
      return
16701 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
16702 
    if self.providerId is not None:
16703 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16704 
      oprot.writeI64(self.providerId)
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 getNonDeliveredOrdersbyCourier_result:
16725 
  """
16726 
  Attributes:
16727 
   - success
16728 
  """
16729 
 
16730 
  thrift_spec = (
16731 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16732 
  )
16733 
 
16734 
  def __init__(self, success=None,):
16735 
    self.success = success
16736 
 
16737 
  def read(self, iprot):
16738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16740 
      return
16741 
    iprot.readStructBegin()
16742 
    while True:
16743 
      (fname, ftype, fid) = iprot.readFieldBegin()
16744 
      if ftype == TType.STOP:
16745 
        break
4581 phani.kuma 16746 
      if fid == 0:
16747 
        if ftype == TType.LIST:
16748 
          self.success = []
6188 rajveer 16749 
          (_etype355, _size352) = iprot.readListBegin()
16750 
          for _i356 in xrange(_size352):
16751 
            _elem357 = Order()
16752 
            _elem357.read(iprot)
16753 
            self.success.append(_elem357)
4581 phani.kuma 16754 
          iprot.readListEnd()
16755 
        else:
16756 
          iprot.skip(ftype)
4910 phani.kuma 16757 
      else:
16758 
        iprot.skip(ftype)
16759 
      iprot.readFieldEnd()
16760 
    iprot.readStructEnd()
16761 
 
16762 
  def write(self, oprot):
16763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16765 
      return
16766 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
16767 
    if self.success is not None:
16768 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16769 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16770 
      for iter358 in self.success:
16771 
        iter358.write(oprot)
4910 phani.kuma 16772 
      oprot.writeListEnd()
16773 
      oprot.writeFieldEnd()
16774 
    oprot.writeFieldStop()
16775 
    oprot.writeStructEnd()
16776 
 
16777 
  def validate(self):
16778 
    return
16779 
 
16780 
 
16781 
  def __repr__(self):
16782 
    L = ['%s=%r' % (key, value)
16783 
      for key, value in self.__dict__.iteritems()]
16784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16785 
 
16786 
  def __eq__(self, other):
16787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16788 
 
16789 
  def __ne__(self, other):
16790 
    return not (self == other)
16791 
 
16792 
class markOrdersAsLocalConnected_args:
16793 
  """
16794 
  Attributes:
16795 
   - providerId
16796 
   - local_connected_orders
16797 
  """
16798 
 
16799 
  thrift_spec = (
16800 
    None, # 0
16801 
    (1, TType.I64, 'providerId', None, None, ), # 1
16802 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16803 
  )
16804 
 
16805 
  def __init__(self, providerId=None, local_connected_orders=None,):
16806 
    self.providerId = providerId
16807 
    self.local_connected_orders = local_connected_orders
16808 
 
16809 
  def read(self, iprot):
16810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16812 
      return
16813 
    iprot.readStructBegin()
16814 
    while True:
16815 
      (fname, ftype, fid) = iprot.readFieldBegin()
16816 
      if ftype == TType.STOP:
16817 
        break
16818 
      if fid == 1:
16819 
        if ftype == TType.I64:
16820 
          self.providerId = iprot.readI64();
16821 
        else:
16822 
          iprot.skip(ftype)
16823 
      elif fid == 2:
16824 
        if ftype == TType.MAP:
16825 
          self.local_connected_orders = {}
6188 rajveer 16826 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16827 
          for _i363 in xrange(_size359):
16828 
            _key364 = iprot.readString();
16829 
            _val365 = iprot.readString();
16830 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16831 
          iprot.readMapEnd()
16832 
        else:
16833 
          iprot.skip(ftype)
16834 
      else:
16835 
        iprot.skip(ftype)
16836 
      iprot.readFieldEnd()
16837 
    iprot.readStructEnd()
16838 
 
16839 
  def write(self, oprot):
16840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16842 
      return
16843 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16844 
    if self.providerId is not None:
16845 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16846 
      oprot.writeI64(self.providerId)
16847 
      oprot.writeFieldEnd()
16848 
    if self.local_connected_orders is not None:
16849 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16850 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16851 
      for kiter366,viter367 in self.local_connected_orders.items():
16852 
        oprot.writeString(kiter366)
16853 
        oprot.writeString(viter367)
4910 phani.kuma 16854 
      oprot.writeMapEnd()
16855 
      oprot.writeFieldEnd()
16856 
    oprot.writeFieldStop()
16857 
    oprot.writeStructEnd()
16858 
 
16859 
  def validate(self):
16860 
    return
16861 
 
16862 
 
16863 
  def __repr__(self):
16864 
    L = ['%s=%r' % (key, value)
16865 
      for key, value in self.__dict__.iteritems()]
16866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16867 
 
16868 
  def __eq__(self, other):
16869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16870 
 
16871 
  def __ne__(self, other):
16872 
    return not (self == other)
16873 
 
16874 
class markOrdersAsLocalConnected_result:
16875 
  """
16876 
  Attributes:
16877 
   - ex
16878 
  """
16879 
 
16880 
  thrift_spec = (
16881 
    None, # 0
16882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16883 
  )
16884 
 
16885 
  def __init__(self, ex=None,):
16886 
    self.ex = ex
16887 
 
16888 
  def read(self, iprot):
16889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16891 
      return
16892 
    iprot.readStructBegin()
16893 
    while True:
16894 
      (fname, ftype, fid) = iprot.readFieldBegin()
16895 
      if ftype == TType.STOP:
16896 
        break
16897 
      if fid == 1:
3064 chandransh 16898 
        if ftype == TType.STRUCT:
16899 
          self.ex = TransactionServiceException()
16900 
          self.ex.read(iprot)
1627 ankur.sing 16901 
        else:
16902 
          iprot.skip(ftype)
16903 
      else:
16904 
        iprot.skip(ftype)
16905 
      iprot.readFieldEnd()
16906 
    iprot.readStructEnd()
16907 
 
16908 
  def write(self, oprot):
16909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16911 
      return
4910 phani.kuma 16912 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16913 
    if self.ex is not None:
16914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16915 
      self.ex.write(oprot)
16916 
      oprot.writeFieldEnd()
16917 
    oprot.writeFieldStop()
16918 
    oprot.writeStructEnd()
16919 
 
16920 
  def validate(self):
16921 
    return
16922 
 
16923 
 
16924 
  def __repr__(self):
16925 
    L = ['%s=%r' % (key, value)
16926 
      for key, value in self.__dict__.iteritems()]
16927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16928 
 
16929 
  def __eq__(self, other):
16930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16931 
 
16932 
  def __ne__(self, other):
16933 
    return not (self == other)
16934 
 
16935 
class getOrdersNotLocalConnected_args:
16936 
  """
16937 
  Attributes:
16938 
   - providerId
16939 
  """
16940 
 
16941 
  thrift_spec = (
16942 
    None, # 0
16943 
    (1, TType.I64, 'providerId', None, None, ), # 1
16944 
  )
16945 
 
16946 
  def __init__(self, providerId=None,):
16947 
    self.providerId = providerId
16948 
 
16949 
  def read(self, iprot):
16950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16952 
      return
16953 
    iprot.readStructBegin()
16954 
    while True:
16955 
      (fname, ftype, fid) = iprot.readFieldBegin()
16956 
      if ftype == TType.STOP:
16957 
        break
16958 
      if fid == 1:
16959 
        if ftype == TType.I64:
16960 
          self.providerId = iprot.readI64();
16961 
        else:
16962 
          iprot.skip(ftype)
16963 
      else:
16964 
        iprot.skip(ftype)
16965 
      iprot.readFieldEnd()
16966 
    iprot.readStructEnd()
16967 
 
16968 
  def write(self, oprot):
16969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16971 
      return
16972 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16973 
    if self.providerId is not None:
16974 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16975 
      oprot.writeI64(self.providerId)
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 getOrdersNotLocalConnected_result:
16996 
  """
16997 
  Attributes:
16998 
   - success
16999 
  """
17000 
 
17001 
  thrift_spec = (
17002 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17003 
  )
17004 
 
17005 
  def __init__(self, success=None,):
17006 
    self.success = success
17007 
 
17008 
  def read(self, iprot):
17009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17011 
      return
17012 
    iprot.readStructBegin()
17013 
    while True:
17014 
      (fname, ftype, fid) = iprot.readFieldBegin()
17015 
      if ftype == TType.STOP:
17016 
        break
17017 
      if fid == 0:
17018 
        if ftype == TType.LIST:
17019 
          self.success = []
6188 rajveer 17020 
          (_etype371, _size368) = iprot.readListBegin()
17021 
          for _i372 in xrange(_size368):
17022 
            _elem373 = Order()
17023 
            _elem373.read(iprot)
17024 
            self.success.append(_elem373)
4910 phani.kuma 17025 
          iprot.readListEnd()
17026 
        else:
17027 
          iprot.skip(ftype)
17028 
      else:
17029 
        iprot.skip(ftype)
17030 
      iprot.readFieldEnd()
17031 
    iprot.readStructEnd()
17032 
 
17033 
  def write(self, oprot):
17034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17036 
      return
17037 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 17038 
    if self.success is not None:
17039 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17040 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17041 
      for iter374 in self.success:
17042 
        iter374.write(oprot)
4581 phani.kuma 17043 
      oprot.writeListEnd()
17044 
      oprot.writeFieldEnd()
4910 phani.kuma 17045 
    oprot.writeFieldStop()
17046 
    oprot.writeStructEnd()
17047 
 
17048 
  def validate(self):
17049 
    return
17050 
 
17051 
 
17052 
  def __repr__(self):
17053 
    L = ['%s=%r' % (key, value)
17054 
      for key, value in self.__dict__.iteritems()]
17055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17056 
 
17057 
  def __eq__(self, other):
17058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17059 
 
17060 
  def __ne__(self, other):
17061 
    return not (self == other)
17062 
 
17063 
class markOrdersAsDestinationCityReached_args:
17064 
  """
17065 
  Attributes:
17066 
   - providerId
17067 
   - destination_city_reached_orders
17068 
  """
17069 
 
17070 
  thrift_spec = (
17071 
    None, # 0
17072 
    (1, TType.I64, 'providerId', None, None, ), # 1
17073 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
17074 
  )
17075 
 
17076 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
17077 
    self.providerId = providerId
17078 
    self.destination_city_reached_orders = destination_city_reached_orders
17079 
 
17080 
  def read(self, iprot):
17081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17083 
      return
17084 
    iprot.readStructBegin()
17085 
    while True:
17086 
      (fname, ftype, fid) = iprot.readFieldBegin()
17087 
      if ftype == TType.STOP:
17088 
        break
17089 
      if fid == 1:
17090 
        if ftype == TType.I64:
17091 
          self.providerId = iprot.readI64();
17092 
        else:
17093 
          iprot.skip(ftype)
17094 
      elif fid == 2:
17095 
        if ftype == TType.MAP:
17096 
          self.destination_city_reached_orders = {}
6188 rajveer 17097 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
17098 
          for _i379 in xrange(_size375):
17099 
            _key380 = iprot.readString();
17100 
            _val381 = iprot.readString();
17101 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 17102 
          iprot.readMapEnd()
17103 
        else:
17104 
          iprot.skip(ftype)
17105 
      else:
17106 
        iprot.skip(ftype)
17107 
      iprot.readFieldEnd()
17108 
    iprot.readStructEnd()
17109 
 
17110 
  def write(self, oprot):
17111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17113 
      return
17114 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
17115 
    if self.providerId is not None:
17116 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17117 
      oprot.writeI64(self.providerId)
17118 
      oprot.writeFieldEnd()
17119 
    if self.destination_city_reached_orders is not None:
17120 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
17121 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 17122 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
17123 
        oprot.writeString(kiter382)
17124 
        oprot.writeString(viter383)
4910 phani.kuma 17125 
      oprot.writeMapEnd()
17126 
      oprot.writeFieldEnd()
17127 
    oprot.writeFieldStop()
17128 
    oprot.writeStructEnd()
17129 
 
17130 
  def validate(self):
17131 
    return
17132 
 
17133 
 
17134 
  def __repr__(self):
17135 
    L = ['%s=%r' % (key, value)
17136 
      for key, value in self.__dict__.iteritems()]
17137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17138 
 
17139 
  def __eq__(self, other):
17140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17141 
 
17142 
  def __ne__(self, other):
17143 
    return not (self == other)
17144 
 
17145 
class markOrdersAsDestinationCityReached_result:
17146 
  """
17147 
  Attributes:
17148 
   - ex
17149 
  """
17150 
 
17151 
  thrift_spec = (
17152 
    None, # 0
17153 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17154 
  )
17155 
 
17156 
  def __init__(self, ex=None,):
17157 
    self.ex = ex
17158 
 
17159 
  def read(self, iprot):
17160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17162 
      return
17163 
    iprot.readStructBegin()
17164 
    while True:
17165 
      (fname, ftype, fid) = iprot.readFieldBegin()
17166 
      if ftype == TType.STOP:
17167 
        break
17168 
      if fid == 1:
17169 
        if ftype == TType.STRUCT:
17170 
          self.ex = TransactionServiceException()
17171 
          self.ex.read(iprot)
17172 
        else:
17173 
          iprot.skip(ftype)
17174 
      else:
17175 
        iprot.skip(ftype)
17176 
      iprot.readFieldEnd()
17177 
    iprot.readStructEnd()
17178 
 
17179 
  def write(self, oprot):
17180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17182 
      return
17183 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 17184 
    if self.ex is not None:
3064 chandransh 17185 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17186 
      self.ex.write(oprot)
1627 ankur.sing 17187 
      oprot.writeFieldEnd()
17188 
    oprot.writeFieldStop()
17189 
    oprot.writeStructEnd()
17190 
 
3431 rajveer 17191 
  def validate(self):
17192 
    return
17193 
 
17194 
 
1627 ankur.sing 17195 
  def __repr__(self):
17196 
    L = ['%s=%r' % (key, value)
17197 
      for key, value in self.__dict__.iteritems()]
17198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17199 
 
17200 
  def __eq__(self, other):
17201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17202 
 
17203 
  def __ne__(self, other):
17204 
    return not (self == other)
17205 
 
4910 phani.kuma 17206 
class markOrdersAsFirstDeliveryAttempted_args:
17207 
  """
17208 
  Attributes:
17209 
   - providerId
17210 
   - first_atdl_orders
17211 
  """
17212 
 
17213 
  thrift_spec = (
17214 
    None, # 0
17215 
    (1, TType.I64, 'providerId', None, None, ), # 1
17216 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
17217 
  )
17218 
 
17219 
  def __init__(self, providerId=None, first_atdl_orders=None,):
17220 
    self.providerId = providerId
17221 
    self.first_atdl_orders = first_atdl_orders
17222 
 
17223 
  def read(self, iprot):
17224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17226 
      return
17227 
    iprot.readStructBegin()
17228 
    while True:
17229 
      (fname, ftype, fid) = iprot.readFieldBegin()
17230 
      if ftype == TType.STOP:
17231 
        break
17232 
      if fid == 1:
17233 
        if ftype == TType.I64:
17234 
          self.providerId = iprot.readI64();
17235 
        else:
17236 
          iprot.skip(ftype)
17237 
      elif fid == 2:
17238 
        if ftype == TType.MAP:
17239 
          self.first_atdl_orders = {}
6188 rajveer 17240 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
17241 
          for _i388 in xrange(_size384):
17242 
            _key389 = iprot.readString();
17243 
            _val390 = iprot.readString();
17244 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 17245 
          iprot.readMapEnd()
17246 
        else:
17247 
          iprot.skip(ftype)
17248 
      else:
17249 
        iprot.skip(ftype)
17250 
      iprot.readFieldEnd()
17251 
    iprot.readStructEnd()
17252 
 
17253 
  def write(self, oprot):
17254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17256 
      return
17257 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
17258 
    if self.providerId is not None:
17259 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17260 
      oprot.writeI64(self.providerId)
17261 
      oprot.writeFieldEnd()
17262 
    if self.first_atdl_orders is not None:
17263 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
17264 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 17265 
      for kiter391,viter392 in self.first_atdl_orders.items():
17266 
        oprot.writeString(kiter391)
17267 
        oprot.writeString(viter392)
4910 phani.kuma 17268 
      oprot.writeMapEnd()
17269 
      oprot.writeFieldEnd()
17270 
    oprot.writeFieldStop()
17271 
    oprot.writeStructEnd()
17272 
 
17273 
  def validate(self):
17274 
    return
17275 
 
17276 
 
17277 
  def __repr__(self):
17278 
    L = ['%s=%r' % (key, value)
17279 
      for key, value in self.__dict__.iteritems()]
17280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17281 
 
17282 
  def __eq__(self, other):
17283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17284 
 
17285 
  def __ne__(self, other):
17286 
    return not (self == other)
17287 
 
17288 
class markOrdersAsFirstDeliveryAttempted_result:
17289 
  """
17290 
  Attributes:
17291 
   - ex
17292 
  """
17293 
 
17294 
  thrift_spec = (
17295 
    None, # 0
17296 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17297 
  )
17298 
 
17299 
  def __init__(self, ex=None,):
17300 
    self.ex = ex
17301 
 
17302 
  def read(self, iprot):
17303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17305 
      return
17306 
    iprot.readStructBegin()
17307 
    while True:
17308 
      (fname, ftype, fid) = iprot.readFieldBegin()
17309 
      if ftype == TType.STOP:
17310 
        break
17311 
      if fid == 1:
17312 
        if ftype == TType.STRUCT:
17313 
          self.ex = TransactionServiceException()
17314 
          self.ex.read(iprot)
17315 
        else:
17316 
          iprot.skip(ftype)
17317 
      else:
17318 
        iprot.skip(ftype)
17319 
      iprot.readFieldEnd()
17320 
    iprot.readStructEnd()
17321 
 
17322 
  def write(self, oprot):
17323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17325 
      return
17326 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
17327 
    if self.ex is not None:
17328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17329 
      self.ex.write(oprot)
17330 
      oprot.writeFieldEnd()
17331 
    oprot.writeFieldStop()
17332 
    oprot.writeStructEnd()
17333 
 
17334 
  def validate(self):
17335 
    return
17336 
 
17337 
 
17338 
  def __repr__(self):
17339 
    L = ['%s=%r' % (key, value)
17340 
      for key, value in self.__dict__.iteritems()]
17341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17342 
 
17343 
  def __eq__(self, other):
17344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17345 
 
17346 
  def __ne__(self, other):
17347 
    return not (self == other)
17348 
 
3064 chandransh 17349 
class getUndeliveredOrders_args:
1886 ankur.sing 17350 
  """
17351 
  Attributes:
3064 chandransh 17352 
   - providerId
17353 
   - warehouseId
1886 ankur.sing 17354 
  """
1627 ankur.sing 17355 
 
1886 ankur.sing 17356 
  thrift_spec = (
17357 
    None, # 0
3064 chandransh 17358 
    (1, TType.I64, 'providerId', None, None, ), # 1
17359 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 17360 
  )
17361 
 
3064 chandransh 17362 
  def __init__(self, providerId=None, warehouseId=None,):
17363 
    self.providerId = providerId
17364 
    self.warehouseId = warehouseId
1886 ankur.sing 17365 
 
17366 
  def read(self, iprot):
17367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17369 
      return
17370 
    iprot.readStructBegin()
17371 
    while True:
17372 
      (fname, ftype, fid) = iprot.readFieldBegin()
17373 
      if ftype == TType.STOP:
17374 
        break
17375 
      if fid == 1:
17376 
        if ftype == TType.I64:
3064 chandransh 17377 
          self.providerId = iprot.readI64();
1886 ankur.sing 17378 
        else:
17379 
          iprot.skip(ftype)
3064 chandransh 17380 
      elif fid == 2:
17381 
        if ftype == TType.I64:
17382 
          self.warehouseId = iprot.readI64();
17383 
        else:
17384 
          iprot.skip(ftype)
1886 ankur.sing 17385 
      else:
17386 
        iprot.skip(ftype)
17387 
      iprot.readFieldEnd()
17388 
    iprot.readStructEnd()
17389 
 
17390 
  def write(self, oprot):
17391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17393 
      return
3064 chandransh 17394 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 17395 
    if self.providerId is not None:
3064 chandransh 17396 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17397 
      oprot.writeI64(self.providerId)
1886 ankur.sing 17398 
      oprot.writeFieldEnd()
3431 rajveer 17399 
    if self.warehouseId is not None:
3064 chandransh 17400 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17401 
      oprot.writeI64(self.warehouseId)
17402 
      oprot.writeFieldEnd()
1886 ankur.sing 17403 
    oprot.writeFieldStop()
17404 
    oprot.writeStructEnd()
17405 
 
3431 rajveer 17406 
  def validate(self):
17407 
    return
17408 
 
17409 
 
1886 ankur.sing 17410 
  def __repr__(self):
17411 
    L = ['%s=%r' % (key, value)
17412 
      for key, value in self.__dict__.iteritems()]
17413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17414 
 
17415 
  def __eq__(self, other):
17416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17417 
 
17418 
  def __ne__(self, other):
17419 
    return not (self == other)
17420 
 
3064 chandransh 17421 
class getUndeliveredOrders_result:
1886 ankur.sing 17422 
  """
17423 
  Attributes:
17424 
   - success
17425 
  """
17426 
 
17427 
  thrift_spec = (
17428 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17429 
  )
17430 
 
17431 
  def __init__(self, success=None,):
17432 
    self.success = success
17433 
 
17434 
  def read(self, iprot):
17435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17437 
      return
17438 
    iprot.readStructBegin()
17439 
    while True:
17440 
      (fname, ftype, fid) = iprot.readFieldBegin()
17441 
      if ftype == TType.STOP:
17442 
        break
17443 
      if fid == 0:
17444 
        if ftype == TType.LIST:
17445 
          self.success = []
6188 rajveer 17446 
          (_etype396, _size393) = iprot.readListBegin()
17447 
          for _i397 in xrange(_size393):
17448 
            _elem398 = Order()
17449 
            _elem398.read(iprot)
17450 
            self.success.append(_elem398)
1886 ankur.sing 17451 
          iprot.readListEnd()
17452 
        else:
17453 
          iprot.skip(ftype)
17454 
      else:
17455 
        iprot.skip(ftype)
17456 
      iprot.readFieldEnd()
17457 
    iprot.readStructEnd()
17458 
 
17459 
  def write(self, oprot):
17460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17462 
      return
3064 chandransh 17463 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 17464 
    if self.success is not None:
1886 ankur.sing 17465 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17466 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17467 
      for iter399 in self.success:
17468 
        iter399.write(oprot)
1886 ankur.sing 17469 
      oprot.writeListEnd()
17470 
      oprot.writeFieldEnd()
17471 
    oprot.writeFieldStop()
17472 
    oprot.writeStructEnd()
17473 
 
3431 rajveer 17474 
  def validate(self):
17475 
    return
17476 
 
17477 
 
1886 ankur.sing 17478 
  def __repr__(self):
17479 
    L = ['%s=%r' % (key, value)
17480 
      for key, value in self.__dict__.iteritems()]
17481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17482 
 
17483 
  def __eq__(self, other):
17484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17485 
 
17486 
  def __ne__(self, other):
17487 
    return not (self == other)
17488 
 
4783 phani.kuma 17489 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
17490 
 
17491 
  thrift_spec = (
17492 
  )
17493 
 
17494 
  def read(self, iprot):
17495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17497 
      return
17498 
    iprot.readStructBegin()
17499 
    while True:
17500 
      (fname, ftype, fid) = iprot.readFieldBegin()
17501 
      if ftype == TType.STOP:
17502 
        break
17503 
      else:
17504 
        iprot.skip(ftype)
17505 
      iprot.readFieldEnd()
17506 
    iprot.readStructEnd()
17507 
 
17508 
  def write(self, oprot):
17509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17511 
      return
17512 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
17513 
    oprot.writeFieldStop()
17514 
    oprot.writeStructEnd()
17515 
 
17516 
  def validate(self):
17517 
    return
17518 
 
17519 
 
17520 
  def __repr__(self):
17521 
    L = ['%s=%r' % (key, value)
17522 
      for key, value in self.__dict__.iteritems()]
17523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17524 
 
17525 
  def __eq__(self, other):
17526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17527 
 
17528 
  def __ne__(self, other):
17529 
    return not (self == other)
17530 
 
17531 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
17532 
  """
17533 
  Attributes:
17534 
   - success
17535 
  """
17536 
 
17537 
  thrift_spec = (
17538 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17539 
  )
17540 
 
17541 
  def __init__(self, success=None,):
17542 
    self.success = success
17543 
 
17544 
  def read(self, iprot):
17545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17547 
      return
17548 
    iprot.readStructBegin()
17549 
    while True:
17550 
      (fname, ftype, fid) = iprot.readFieldBegin()
17551 
      if ftype == TType.STOP:
17552 
        break
17553 
      if fid == 0:
17554 
        if ftype == TType.LIST:
17555 
          self.success = []
6188 rajveer 17556 
          (_etype403, _size400) = iprot.readListBegin()
17557 
          for _i404 in xrange(_size400):
17558 
            _elem405 = Order()
17559 
            _elem405.read(iprot)
17560 
            self.success.append(_elem405)
4783 phani.kuma 17561 
          iprot.readListEnd()
17562 
        else:
17563 
          iprot.skip(ftype)
17564 
      else:
17565 
        iprot.skip(ftype)
17566 
      iprot.readFieldEnd()
17567 
    iprot.readStructEnd()
17568 
 
17569 
  def write(self, oprot):
17570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17572 
      return
17573 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
17574 
    if self.success is not None:
17575 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17576 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17577 
      for iter406 in self.success:
17578 
        iter406.write(oprot)
4783 phani.kuma 17579 
      oprot.writeListEnd()
17580 
      oprot.writeFieldEnd()
17581 
    oprot.writeFieldStop()
17582 
    oprot.writeStructEnd()
17583 
 
17584 
  def validate(self):
17585 
    return
17586 
 
17587 
 
17588 
  def __repr__(self):
17589 
    L = ['%s=%r' % (key, value)
17590 
      for key, value in self.__dict__.iteritems()]
17591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17592 
 
17593 
  def __eq__(self, other):
17594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17595 
 
17596 
  def __ne__(self, other):
17597 
    return not (self == other)
17598 
 
2536 chandransh 17599 
class toggleDOAFlag_args:
17600 
  """
17601 
  Attributes:
17602 
   - orderId
17603 
  """
1886 ankur.sing 17604 
 
2536 chandransh 17605 
  thrift_spec = (
17606 
    None, # 0
17607 
    (1, TType.I64, 'orderId', None, None, ), # 1
17608 
  )
17609 
 
17610 
  def __init__(self, orderId=None,):
17611 
    self.orderId = orderId
17612 
 
17613 
  def read(self, iprot):
17614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17616 
      return
17617 
    iprot.readStructBegin()
17618 
    while True:
17619 
      (fname, ftype, fid) = iprot.readFieldBegin()
17620 
      if ftype == TType.STOP:
17621 
        break
17622 
      if fid == 1:
17623 
        if ftype == TType.I64:
17624 
          self.orderId = iprot.readI64();
17625 
        else:
17626 
          iprot.skip(ftype)
17627 
      else:
17628 
        iprot.skip(ftype)
17629 
      iprot.readFieldEnd()
17630 
    iprot.readStructEnd()
17631 
 
17632 
  def write(self, oprot):
17633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17635 
      return
17636 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 17637 
    if self.orderId is not None:
2536 chandransh 17638 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17639 
      oprot.writeI64(self.orderId)
17640 
      oprot.writeFieldEnd()
17641 
    oprot.writeFieldStop()
17642 
    oprot.writeStructEnd()
17643 
 
3431 rajveer 17644 
  def validate(self):
17645 
    return
17646 
 
17647 
 
2536 chandransh 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 toggleDOAFlag_result:
17660 
  """
17661 
  Attributes:
17662 
   - success
17663 
   - ex
17664 
  """
17665 
 
17666 
  thrift_spec = (
17667 
    (0, TType.BOOL, 'success', None, None, ), # 0
17668 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17669 
  )
17670 
 
17671 
  def __init__(self, success=None, ex=None,):
17672 
    self.success = success
17673 
    self.ex = ex
17674 
 
17675 
  def read(self, iprot):
17676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17678 
      return
17679 
    iprot.readStructBegin()
17680 
    while True:
17681 
      (fname, ftype, fid) = iprot.readFieldBegin()
17682 
      if ftype == TType.STOP:
17683 
        break
17684 
      if fid == 0:
17685 
        if ftype == TType.BOOL:
17686 
          self.success = iprot.readBool();
17687 
        else:
17688 
          iprot.skip(ftype)
17689 
      elif fid == 1:
17690 
        if ftype == TType.STRUCT:
17691 
          self.ex = TransactionServiceException()
17692 
          self.ex.read(iprot)
17693 
        else:
17694 
          iprot.skip(ftype)
17695 
      else:
17696 
        iprot.skip(ftype)
17697 
      iprot.readFieldEnd()
17698 
    iprot.readStructEnd()
17699 
 
17700 
  def write(self, oprot):
17701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17703 
      return
17704 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 17705 
    if self.success is not None:
2536 chandransh 17706 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17707 
      oprot.writeBool(self.success)
17708 
      oprot.writeFieldEnd()
3431 rajveer 17709 
    if self.ex is not None:
2536 chandransh 17710 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17711 
      self.ex.write(oprot)
17712 
      oprot.writeFieldEnd()
17713 
    oprot.writeFieldStop()
17714 
    oprot.writeStructEnd()
17715 
 
3431 rajveer 17716 
  def validate(self):
17717 
    return
17718 
 
17719 
 
2536 chandransh 17720 
  def __repr__(self):
17721 
    L = ['%s=%r' % (key, value)
17722 
      for key, value in self.__dict__.iteritems()]
17723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17724 
 
17725 
  def __eq__(self, other):
17726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17727 
 
17728 
  def __ne__(self, other):
17729 
    return not (self == other)
17730 
 
4712 rajveer 17731 
class markOrderAsDelivered_args:
17732 
  """
17733 
  Attributes:
17734 
   - orderId
17735 
   - deliveryTimestamp
17736 
   - receiver
17737 
  """
17738 
 
17739 
  thrift_spec = None
17740 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
17741 
    self.orderId = orderId
17742 
    self.deliveryTimestamp = deliveryTimestamp
17743 
    self.receiver = receiver
17744 
 
17745 
  def read(self, iprot):
17746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17748 
      return
17749 
    iprot.readStructBegin()
17750 
    while True:
17751 
      (fname, ftype, fid) = iprot.readFieldBegin()
17752 
      if ftype == TType.STOP:
17753 
        break
17754 
      if fid == 1:
17755 
        if ftype == TType.I64:
17756 
          self.orderId = iprot.readI64();
17757 
        else:
17758 
          iprot.skip(ftype)
17759 
      elif fid == 2:
17760 
        if ftype == TType.I64:
17761 
          self.deliveryTimestamp = iprot.readI64();
17762 
        else:
17763 
          iprot.skip(ftype)
17764 
      elif fid == -1:
17765 
        if ftype == TType.STRING:
17766 
          self.receiver = iprot.readString();
17767 
        else:
17768 
          iprot.skip(ftype)
17769 
      else:
17770 
        iprot.skip(ftype)
17771 
      iprot.readFieldEnd()
17772 
    iprot.readStructEnd()
17773 
 
17774 
  def write(self, oprot):
17775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17777 
      return
17778 
    oprot.writeStructBegin('markOrderAsDelivered_args')
17779 
    if self.receiver is not None:
17780 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
17781 
      oprot.writeString(self.receiver)
17782 
      oprot.writeFieldEnd()
17783 
    if self.orderId is not None:
17784 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17785 
      oprot.writeI64(self.orderId)
17786 
      oprot.writeFieldEnd()
17787 
    if self.deliveryTimestamp is not None:
17788 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17789 
      oprot.writeI64(self.deliveryTimestamp)
17790 
      oprot.writeFieldEnd()
17791 
    oprot.writeFieldStop()
17792 
    oprot.writeStructEnd()
17793 
 
17794 
  def validate(self):
17795 
    return
17796 
 
17797 
 
17798 
  def __repr__(self):
17799 
    L = ['%s=%r' % (key, value)
17800 
      for key, value in self.__dict__.iteritems()]
17801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17802 
 
17803 
  def __eq__(self, other):
17804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17805 
 
17806 
  def __ne__(self, other):
17807 
    return not (self == other)
17808 
 
17809 
class markOrderAsDelivered_result:
17810 
  """
17811 
  Attributes:
17812 
   - ex
17813 
  """
17814 
 
17815 
  thrift_spec = (
17816 
    None, # 0
17817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17818 
  )
17819 
 
17820 
  def __init__(self, ex=None,):
17821 
    self.ex = ex
17822 
 
17823 
  def read(self, iprot):
17824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17826 
      return
17827 
    iprot.readStructBegin()
17828 
    while True:
17829 
      (fname, ftype, fid) = iprot.readFieldBegin()
17830 
      if ftype == TType.STOP:
17831 
        break
17832 
      if fid == 1:
17833 
        if ftype == TType.STRUCT:
17834 
          self.ex = TransactionServiceException()
17835 
          self.ex.read(iprot)
17836 
        else:
17837 
          iprot.skip(ftype)
17838 
      else:
17839 
        iprot.skip(ftype)
17840 
      iprot.readFieldEnd()
17841 
    iprot.readStructEnd()
17842 
 
17843 
  def write(self, oprot):
17844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17846 
      return
17847 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17848 
    if self.ex is not None:
17849 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17850 
      self.ex.write(oprot)
17851 
      oprot.writeFieldEnd()
17852 
    oprot.writeFieldStop()
17853 
    oprot.writeStructEnd()
17854 
 
17855 
  def validate(self):
17856 
    return
17857 
 
17858 
 
17859 
  def __repr__(self):
17860 
    L = ['%s=%r' % (key, value)
17861 
      for key, value in self.__dict__.iteritems()]
17862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17863 
 
17864 
  def __eq__(self, other):
17865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17866 
 
17867 
  def __ne__(self, other):
17868 
    return not (self == other)
17869 
 
5553 rajveer 17870 
class markOrderAsReceivedAtStore_args:
17871 
  """
17872 
  Attributes:
17873 
   - orderId
17874 
   - deliveryTimestamp
17875 
  """
17876 
 
17877 
  thrift_spec = (
17878 
    None, # 0
17879 
    (1, TType.I64, 'orderId', None, None, ), # 1
17880 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17881 
  )
17882 
 
17883 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17884 
    self.orderId = orderId
17885 
    self.deliveryTimestamp = deliveryTimestamp
17886 
 
17887 
  def read(self, iprot):
17888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17890 
      return
17891 
    iprot.readStructBegin()
17892 
    while True:
17893 
      (fname, ftype, fid) = iprot.readFieldBegin()
17894 
      if ftype == TType.STOP:
17895 
        break
17896 
      if fid == 1:
17897 
        if ftype == TType.I64:
17898 
          self.orderId = iprot.readI64();
17899 
        else:
17900 
          iprot.skip(ftype)
17901 
      elif fid == 2:
17902 
        if ftype == TType.I64:
17903 
          self.deliveryTimestamp = iprot.readI64();
17904 
        else:
17905 
          iprot.skip(ftype)
17906 
      else:
17907 
        iprot.skip(ftype)
17908 
      iprot.readFieldEnd()
17909 
    iprot.readStructEnd()
17910 
 
17911 
  def write(self, oprot):
17912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17914 
      return
17915 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17916 
    if self.orderId is not None:
17917 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17918 
      oprot.writeI64(self.orderId)
17919 
      oprot.writeFieldEnd()
17920 
    if self.deliveryTimestamp is not None:
17921 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17922 
      oprot.writeI64(self.deliveryTimestamp)
17923 
      oprot.writeFieldEnd()
17924 
    oprot.writeFieldStop()
17925 
    oprot.writeStructEnd()
17926 
 
17927 
  def validate(self):
17928 
    return
17929 
 
17930 
 
17931 
  def __repr__(self):
17932 
    L = ['%s=%r' % (key, value)
17933 
      for key, value in self.__dict__.iteritems()]
17934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17935 
 
17936 
  def __eq__(self, other):
17937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17938 
 
17939 
  def __ne__(self, other):
17940 
    return not (self == other)
17941 
 
17942 
class markOrderAsReceivedAtStore_result:
17943 
  """
17944 
  Attributes:
17945 
   - ex
17946 
  """
17947 
 
17948 
  thrift_spec = (
17949 
    None, # 0
17950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17951 
  )
17952 
 
17953 
  def __init__(self, ex=None,):
17954 
    self.ex = ex
17955 
 
17956 
  def read(self, iprot):
17957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17959 
      return
17960 
    iprot.readStructBegin()
17961 
    while True:
17962 
      (fname, ftype, fid) = iprot.readFieldBegin()
17963 
      if ftype == TType.STOP:
17964 
        break
17965 
      if fid == 1:
17966 
        if ftype == TType.STRUCT:
17967 
          self.ex = TransactionServiceException()
17968 
          self.ex.read(iprot)
17969 
        else:
17970 
          iprot.skip(ftype)
17971 
      else:
17972 
        iprot.skip(ftype)
17973 
      iprot.readFieldEnd()
17974 
    iprot.readStructEnd()
17975 
 
17976 
  def write(self, oprot):
17977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17979 
      return
17980 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17981 
    if self.ex is not None:
17982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17983 
      self.ex.write(oprot)
17984 
      oprot.writeFieldEnd()
17985 
    oprot.writeFieldStop()
17986 
    oprot.writeStructEnd()
17987 
 
17988 
  def validate(self):
17989 
    return
17990 
 
17991 
 
17992 
  def __repr__(self):
17993 
    L = ['%s=%r' % (key, value)
17994 
      for key, value in self.__dict__.iteritems()]
17995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17996 
 
17997 
  def __eq__(self, other):
17998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17999 
 
18000 
  def __ne__(self, other):
18001 
    return not (self == other)
18002 
 
4454 rajveer 18003 
class markOrderDoaRequestReceived_args:
18004 
  """
18005 
  Attributes:
18006 
   - orderId
18007 
  """
18008 
 
18009 
  thrift_spec = (
18010 
    None, # 0
18011 
    (1, TType.I64, 'orderId', None, None, ), # 1
18012 
  )
18013 
 
18014 
  def __init__(self, orderId=None,):
18015 
    self.orderId = orderId
18016 
 
18017 
  def read(self, iprot):
18018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18020 
      return
18021 
    iprot.readStructBegin()
18022 
    while True:
18023 
      (fname, ftype, fid) = iprot.readFieldBegin()
18024 
      if ftype == TType.STOP:
18025 
        break
18026 
      if fid == 1:
18027 
        if ftype == TType.I64:
18028 
          self.orderId = iprot.readI64();
18029 
        else:
18030 
          iprot.skip(ftype)
18031 
      else:
18032 
        iprot.skip(ftype)
18033 
      iprot.readFieldEnd()
18034 
    iprot.readStructEnd()
18035 
 
18036 
  def write(self, oprot):
18037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18039 
      return
18040 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
18041 
    if self.orderId is not None:
18042 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18043 
      oprot.writeI64(self.orderId)
18044 
      oprot.writeFieldEnd()
18045 
    oprot.writeFieldStop()
18046 
    oprot.writeStructEnd()
18047 
 
18048 
  def validate(self):
18049 
    return
18050 
 
18051 
 
18052 
  def __repr__(self):
18053 
    L = ['%s=%r' % (key, value)
18054 
      for key, value in self.__dict__.iteritems()]
18055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18056 
 
18057 
  def __eq__(self, other):
18058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18059 
 
18060 
  def __ne__(self, other):
18061 
    return not (self == other)
18062 
 
18063 
class markOrderDoaRequestReceived_result:
18064 
  """
18065 
  Attributes:
18066 
   - success
18067 
   - ex
18068 
  """
18069 
 
18070 
  thrift_spec = (
18071 
    (0, TType.BOOL, 'success', None, None, ), # 0
18072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18073 
  )
18074 
 
18075 
  def __init__(self, success=None, ex=None,):
18076 
    self.success = success
18077 
    self.ex = ex
18078 
 
18079 
  def read(self, iprot):
18080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18082 
      return
18083 
    iprot.readStructBegin()
18084 
    while True:
18085 
      (fname, ftype, fid) = iprot.readFieldBegin()
18086 
      if ftype == TType.STOP:
18087 
        break
18088 
      if fid == 0:
18089 
        if ftype == TType.BOOL:
18090 
          self.success = iprot.readBool();
18091 
        else:
18092 
          iprot.skip(ftype)
18093 
      elif fid == 1:
18094 
        if ftype == TType.STRUCT:
18095 
          self.ex = TransactionServiceException()
18096 
          self.ex.read(iprot)
18097 
        else:
18098 
          iprot.skip(ftype)
18099 
      else:
18100 
        iprot.skip(ftype)
18101 
      iprot.readFieldEnd()
18102 
    iprot.readStructEnd()
18103 
 
18104 
  def write(self, oprot):
18105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18107 
      return
18108 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
18109 
    if self.success is not None:
18110 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18111 
      oprot.writeBool(self.success)
18112 
      oprot.writeFieldEnd()
18113 
    if self.ex is not None:
18114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18115 
      self.ex.write(oprot)
18116 
      oprot.writeFieldEnd()
18117 
    oprot.writeFieldStop()
18118 
    oprot.writeStructEnd()
18119 
 
18120 
  def validate(self):
18121 
    return
18122 
 
18123 
 
18124 
  def __repr__(self):
18125 
    L = ['%s=%r' % (key, value)
18126 
      for key, value in self.__dict__.iteritems()]
18127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18128 
 
18129 
  def __eq__(self, other):
18130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18131 
 
18132 
  def __ne__(self, other):
18133 
    return not (self == other)
18134 
 
18135 
class markOrderDoaRequestAuthorized_args:
18136 
  """
18137 
  Attributes:
18138 
   - orderId
18139 
   - isAuthorized
18140 
  """
18141 
 
18142 
  thrift_spec = (
18143 
    None, # 0
18144 
    (1, TType.I64, 'orderId', None, None, ), # 1
18145 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
18146 
  )
18147 
 
18148 
  def __init__(self, orderId=None, isAuthorized=None,):
18149 
    self.orderId = orderId
18150 
    self.isAuthorized = isAuthorized
18151 
 
18152 
  def read(self, iprot):
18153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18155 
      return
18156 
    iprot.readStructBegin()
18157 
    while True:
18158 
      (fname, ftype, fid) = iprot.readFieldBegin()
18159 
      if ftype == TType.STOP:
18160 
        break
18161 
      if fid == 1:
18162 
        if ftype == TType.I64:
18163 
          self.orderId = iprot.readI64();
18164 
        else:
18165 
          iprot.skip(ftype)
18166 
      elif fid == 2:
18167 
        if ftype == TType.BOOL:
18168 
          self.isAuthorized = iprot.readBool();
18169 
        else:
18170 
          iprot.skip(ftype)
18171 
      else:
18172 
        iprot.skip(ftype)
18173 
      iprot.readFieldEnd()
18174 
    iprot.readStructEnd()
18175 
 
18176 
  def write(self, oprot):
18177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18179 
      return
18180 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
18181 
    if self.orderId is not None:
18182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18183 
      oprot.writeI64(self.orderId)
18184 
      oprot.writeFieldEnd()
18185 
    if self.isAuthorized is not None:
18186 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
18187 
      oprot.writeBool(self.isAuthorized)
18188 
      oprot.writeFieldEnd()
18189 
    oprot.writeFieldStop()
18190 
    oprot.writeStructEnd()
18191 
 
18192 
  def validate(self):
18193 
    return
18194 
 
18195 
 
18196 
  def __repr__(self):
18197 
    L = ['%s=%r' % (key, value)
18198 
      for key, value in self.__dict__.iteritems()]
18199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18200 
 
18201 
  def __eq__(self, other):
18202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18203 
 
18204 
  def __ne__(self, other):
18205 
    return not (self == other)
18206 
 
18207 
class markOrderDoaRequestAuthorized_result:
18208 
  """
18209 
  Attributes:
18210 
   - success
18211 
   - ex
18212 
  """
18213 
 
18214 
  thrift_spec = (
18215 
    (0, TType.BOOL, 'success', None, None, ), # 0
18216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18217 
  )
18218 
 
18219 
  def __init__(self, success=None, ex=None,):
18220 
    self.success = success
18221 
    self.ex = ex
18222 
 
18223 
  def read(self, iprot):
18224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18226 
      return
18227 
    iprot.readStructBegin()
18228 
    while True:
18229 
      (fname, ftype, fid) = iprot.readFieldBegin()
18230 
      if ftype == TType.STOP:
18231 
        break
18232 
      if fid == 0:
18233 
        if ftype == TType.BOOL:
18234 
          self.success = iprot.readBool();
18235 
        else:
18236 
          iprot.skip(ftype)
18237 
      elif fid == 1:
18238 
        if ftype == TType.STRUCT:
18239 
          self.ex = TransactionServiceException()
18240 
          self.ex.read(iprot)
18241 
        else:
18242 
          iprot.skip(ftype)
18243 
      else:
18244 
        iprot.skip(ftype)
18245 
      iprot.readFieldEnd()
18246 
    iprot.readStructEnd()
18247 
 
18248 
  def write(self, oprot):
18249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18251 
      return
18252 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
18253 
    if self.success is not None:
18254 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18255 
      oprot.writeBool(self.success)
18256 
      oprot.writeFieldEnd()
18257 
    if self.ex is not None:
18258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18259 
      self.ex.write(oprot)
18260 
      oprot.writeFieldEnd()
18261 
    oprot.writeFieldStop()
18262 
    oprot.writeStructEnd()
18263 
 
18264 
  def validate(self):
18265 
    return
18266 
 
18267 
 
18268 
  def __repr__(self):
18269 
    L = ['%s=%r' % (key, value)
18270 
      for key, value in self.__dict__.iteritems()]
18271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18272 
 
18273 
  def __eq__(self, other):
18274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18275 
 
18276 
  def __ne__(self, other):
18277 
    return not (self == other)
18278 
 
4488 rajveer 18279 
class markOrderReturnRequestReceived_args:
18280 
  """
18281 
  Attributes:
18282 
   - orderId
18283 
  """
18284 
 
18285 
  thrift_spec = (
18286 
    None, # 0
18287 
    (1, TType.I64, 'orderId', None, None, ), # 1
18288 
  )
18289 
 
18290 
  def __init__(self, orderId=None,):
18291 
    self.orderId = orderId
18292 
 
18293 
  def read(self, iprot):
18294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18296 
      return
18297 
    iprot.readStructBegin()
18298 
    while True:
18299 
      (fname, ftype, fid) = iprot.readFieldBegin()
18300 
      if ftype == TType.STOP:
18301 
        break
18302 
      if fid == 1:
18303 
        if ftype == TType.I64:
18304 
          self.orderId = iprot.readI64();
18305 
        else:
18306 
          iprot.skip(ftype)
18307 
      else:
18308 
        iprot.skip(ftype)
18309 
      iprot.readFieldEnd()
18310 
    iprot.readStructEnd()
18311 
 
18312 
  def write(self, oprot):
18313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18315 
      return
18316 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
18317 
    if self.orderId is not None:
18318 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18319 
      oprot.writeI64(self.orderId)
18320 
      oprot.writeFieldEnd()
18321 
    oprot.writeFieldStop()
18322 
    oprot.writeStructEnd()
18323 
 
18324 
  def validate(self):
18325 
    return
18326 
 
18327 
 
18328 
  def __repr__(self):
18329 
    L = ['%s=%r' % (key, value)
18330 
      for key, value in self.__dict__.iteritems()]
18331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18332 
 
18333 
  def __eq__(self, other):
18334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18335 
 
18336 
  def __ne__(self, other):
18337 
    return not (self == other)
18338 
 
18339 
class markOrderReturnRequestReceived_result:
18340 
  """
18341 
  Attributes:
18342 
   - success
18343 
   - ex
18344 
  """
18345 
 
18346 
  thrift_spec = (
18347 
    (0, TType.BOOL, 'success', None, None, ), # 0
18348 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18349 
  )
18350 
 
18351 
  def __init__(self, success=None, ex=None,):
18352 
    self.success = success
18353 
    self.ex = ex
18354 
 
18355 
  def read(self, iprot):
18356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18358 
      return
18359 
    iprot.readStructBegin()
18360 
    while True:
18361 
      (fname, ftype, fid) = iprot.readFieldBegin()
18362 
      if ftype == TType.STOP:
18363 
        break
18364 
      if fid == 0:
18365 
        if ftype == TType.BOOL:
18366 
          self.success = iprot.readBool();
18367 
        else:
18368 
          iprot.skip(ftype)
18369 
      elif fid == 1:
18370 
        if ftype == TType.STRUCT:
18371 
          self.ex = TransactionServiceException()
18372 
          self.ex.read(iprot)
18373 
        else:
18374 
          iprot.skip(ftype)
18375 
      else:
18376 
        iprot.skip(ftype)
18377 
      iprot.readFieldEnd()
18378 
    iprot.readStructEnd()
18379 
 
18380 
  def write(self, oprot):
18381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18383 
      return
18384 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
18385 
    if self.success is not None:
18386 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18387 
      oprot.writeBool(self.success)
18388 
      oprot.writeFieldEnd()
18389 
    if self.ex is not None:
18390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18391 
      self.ex.write(oprot)
18392 
      oprot.writeFieldEnd()
18393 
    oprot.writeFieldStop()
18394 
    oprot.writeStructEnd()
18395 
 
18396 
  def validate(self):
18397 
    return
18398 
 
18399 
 
18400 
  def __repr__(self):
18401 
    L = ['%s=%r' % (key, value)
18402 
      for key, value in self.__dict__.iteritems()]
18403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18404 
 
18405 
  def __eq__(self, other):
18406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18407 
 
18408 
  def __ne__(self, other):
18409 
    return not (self == other)
18410 
 
18411 
class markOrderReturnRequestAuthorized_args:
18412 
  """
18413 
  Attributes:
18414 
   - orderId
18415 
   - isAuthorized
18416 
  """
18417 
 
18418 
  thrift_spec = (
18419 
    None, # 0
18420 
    (1, TType.I64, 'orderId', None, None, ), # 1
18421 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
18422 
  )
18423 
 
18424 
  def __init__(self, orderId=None, isAuthorized=None,):
18425 
    self.orderId = orderId
18426 
    self.isAuthorized = isAuthorized
18427 
 
18428 
  def read(self, iprot):
18429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18431 
      return
18432 
    iprot.readStructBegin()
18433 
    while True:
18434 
      (fname, ftype, fid) = iprot.readFieldBegin()
18435 
      if ftype == TType.STOP:
18436 
        break
18437 
      if fid == 1:
18438 
        if ftype == TType.I64:
18439 
          self.orderId = iprot.readI64();
18440 
        else:
18441 
          iprot.skip(ftype)
18442 
      elif fid == 2:
18443 
        if ftype == TType.BOOL:
18444 
          self.isAuthorized = iprot.readBool();
18445 
        else:
18446 
          iprot.skip(ftype)
18447 
      else:
18448 
        iprot.skip(ftype)
18449 
      iprot.readFieldEnd()
18450 
    iprot.readStructEnd()
18451 
 
18452 
  def write(self, oprot):
18453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18455 
      return
18456 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
18457 
    if self.orderId is not None:
18458 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18459 
      oprot.writeI64(self.orderId)
18460 
      oprot.writeFieldEnd()
18461 
    if self.isAuthorized is not None:
18462 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
18463 
      oprot.writeBool(self.isAuthorized)
18464 
      oprot.writeFieldEnd()
18465 
    oprot.writeFieldStop()
18466 
    oprot.writeStructEnd()
18467 
 
18468 
  def validate(self):
18469 
    return
18470 
 
18471 
 
18472 
  def __repr__(self):
18473 
    L = ['%s=%r' % (key, value)
18474 
      for key, value in self.__dict__.iteritems()]
18475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18476 
 
18477 
  def __eq__(self, other):
18478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18479 
 
18480 
  def __ne__(self, other):
18481 
    return not (self == other)
18482 
 
18483 
class markOrderReturnRequestAuthorized_result:
18484 
  """
18485 
  Attributes:
18486 
   - success
18487 
   - ex
18488 
  """
18489 
 
18490 
  thrift_spec = (
18491 
    (0, TType.BOOL, 'success', None, None, ), # 0
18492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18493 
  )
18494 
 
18495 
  def __init__(self, success=None, ex=None,):
18496 
    self.success = success
18497 
    self.ex = ex
18498 
 
18499 
  def read(self, iprot):
18500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18502 
      return
18503 
    iprot.readStructBegin()
18504 
    while True:
18505 
      (fname, ftype, fid) = iprot.readFieldBegin()
18506 
      if ftype == TType.STOP:
18507 
        break
18508 
      if fid == 0:
18509 
        if ftype == TType.BOOL:
18510 
          self.success = iprot.readBool();
18511 
        else:
18512 
          iprot.skip(ftype)
18513 
      elif fid == 1:
18514 
        if ftype == TType.STRUCT:
18515 
          self.ex = TransactionServiceException()
18516 
          self.ex.read(iprot)
18517 
        else:
18518 
          iprot.skip(ftype)
18519 
      else:
18520 
        iprot.skip(ftype)
18521 
      iprot.readFieldEnd()
18522 
    iprot.readStructEnd()
18523 
 
18524 
  def write(self, oprot):
18525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18527 
      return
18528 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
18529 
    if self.success is not None:
18530 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18531 
      oprot.writeBool(self.success)
18532 
      oprot.writeFieldEnd()
18533 
    if self.ex is not None:
18534 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18535 
      self.ex.write(oprot)
18536 
      oprot.writeFieldEnd()
18537 
    oprot.writeFieldStop()
18538 
    oprot.writeStructEnd()
18539 
 
18540 
  def validate(self):
18541 
    return
18542 
 
18543 
 
18544 
  def __repr__(self):
18545 
    L = ['%s=%r' % (key, value)
18546 
      for key, value in self.__dict__.iteritems()]
18547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18548 
 
18549 
  def __eq__(self, other):
18550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18551 
 
18552 
  def __ne__(self, other):
18553 
    return not (self == other)
18554 
 
2536 chandransh 18555 
class requestPickupNumber_args:
18556 
  """
18557 
  Attributes:
18558 
   - orderId
4579 rajveer 18559 
   - providerId
2536 chandransh 18560 
  """
18561 
 
18562 
  thrift_spec = (
18563 
    None, # 0
18564 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 18565 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 18566 
  )
18567 
 
4579 rajveer 18568 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 18569 
    self.orderId = orderId
4579 rajveer 18570 
    self.providerId = providerId
2536 chandransh 18571 
 
18572 
  def read(self, iprot):
18573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18575 
      return
18576 
    iprot.readStructBegin()
18577 
    while True:
18578 
      (fname, ftype, fid) = iprot.readFieldBegin()
18579 
      if ftype == TType.STOP:
18580 
        break
18581 
      if fid == 1:
18582 
        if ftype == TType.I64:
18583 
          self.orderId = iprot.readI64();
18584 
        else:
18585 
          iprot.skip(ftype)
4579 rajveer 18586 
      elif fid == 2:
18587 
        if ftype == TType.I64:
18588 
          self.providerId = iprot.readI64();
18589 
        else:
18590 
          iprot.skip(ftype)
2536 chandransh 18591 
      else:
18592 
        iprot.skip(ftype)
18593 
      iprot.readFieldEnd()
18594 
    iprot.readStructEnd()
18595 
 
18596 
  def write(self, oprot):
18597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18599 
      return
18600 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 18601 
    if self.orderId is not None:
2536 chandransh 18602 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18603 
      oprot.writeI64(self.orderId)
18604 
      oprot.writeFieldEnd()
4579 rajveer 18605 
    if self.providerId is not None:
18606 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
18607 
      oprot.writeI64(self.providerId)
18608 
      oprot.writeFieldEnd()
2536 chandransh 18609 
    oprot.writeFieldStop()
18610 
    oprot.writeStructEnd()
18611 
 
3431 rajveer 18612 
  def validate(self):
18613 
    return
18614 
 
18615 
 
2536 chandransh 18616 
  def __repr__(self):
18617 
    L = ['%s=%r' % (key, value)
18618 
      for key, value in self.__dict__.iteritems()]
18619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18620 
 
18621 
  def __eq__(self, other):
18622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18623 
 
18624 
  def __ne__(self, other):
18625 
    return not (self == other)
18626 
 
18627 
class requestPickupNumber_result:
18628 
  """
18629 
  Attributes:
18630 
   - success
18631 
   - ex
18632 
  """
18633 
 
18634 
  thrift_spec = (
18635 
    (0, TType.BOOL, 'success', None, None, ), # 0
18636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18637 
  )
18638 
 
18639 
  def __init__(self, success=None, ex=None,):
18640 
    self.success = success
18641 
    self.ex = ex
18642 
 
18643 
  def read(self, iprot):
18644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18646 
      return
18647 
    iprot.readStructBegin()
18648 
    while True:
18649 
      (fname, ftype, fid) = iprot.readFieldBegin()
18650 
      if ftype == TType.STOP:
18651 
        break
18652 
      if fid == 0:
18653 
        if ftype == TType.BOOL:
18654 
          self.success = iprot.readBool();
18655 
        else:
18656 
          iprot.skip(ftype)
18657 
      elif fid == 1:
18658 
        if ftype == TType.STRUCT:
18659 
          self.ex = TransactionServiceException()
18660 
          self.ex.read(iprot)
18661 
        else:
18662 
          iprot.skip(ftype)
18663 
      else:
18664 
        iprot.skip(ftype)
18665 
      iprot.readFieldEnd()
18666 
    iprot.readStructEnd()
18667 
 
18668 
  def write(self, oprot):
18669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18671 
      return
18672 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 18673 
    if self.success is not None:
2536 chandransh 18674 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18675 
      oprot.writeBool(self.success)
18676 
      oprot.writeFieldEnd()
3431 rajveer 18677 
    if self.ex is not None:
2536 chandransh 18678 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18679 
      self.ex.write(oprot)
18680 
      oprot.writeFieldEnd()
18681 
    oprot.writeFieldStop()
18682 
    oprot.writeStructEnd()
18683 
 
3431 rajveer 18684 
  def validate(self):
18685 
    return
18686 
 
18687 
 
2536 chandransh 18688 
  def __repr__(self):
18689 
    L = ['%s=%r' % (key, value)
18690 
      for key, value in self.__dict__.iteritems()]
18691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18692 
 
18693 
  def __eq__(self, other):
18694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18695 
 
18696 
  def __ne__(self, other):
18697 
    return not (self == other)
18698 
 
18699 
class authorizePickup_args:
18700 
  """
18701 
  Attributes:
18702 
   - orderId
18703 
   - pickupNumber
4602 rajveer 18704 
   - providerId
2536 chandransh 18705 
  """
18706 
 
18707 
  thrift_spec = (
18708 
    None, # 0
18709 
    (1, TType.I64, 'orderId', None, None, ), # 1
18710 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 18711 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 18712 
  )
18713 
 
4602 rajveer 18714 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 18715 
    self.orderId = orderId
18716 
    self.pickupNumber = pickupNumber
4602 rajveer 18717 
    self.providerId = providerId
2536 chandransh 18718 
 
18719 
  def read(self, iprot):
18720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18722 
      return
18723 
    iprot.readStructBegin()
18724 
    while True:
18725 
      (fname, ftype, fid) = iprot.readFieldBegin()
18726 
      if ftype == TType.STOP:
18727 
        break
18728 
      if fid == 1:
18729 
        if ftype == TType.I64:
18730 
          self.orderId = iprot.readI64();
18731 
        else:
18732 
          iprot.skip(ftype)
18733 
      elif fid == 2:
18734 
        if ftype == TType.STRING:
18735 
          self.pickupNumber = iprot.readString();
18736 
        else:
18737 
          iprot.skip(ftype)
4602 rajveer 18738 
      elif fid == 3:
18739 
        if ftype == TType.I64:
18740 
          self.providerId = iprot.readI64();
18741 
        else:
18742 
          iprot.skip(ftype)
2536 chandransh 18743 
      else:
18744 
        iprot.skip(ftype)
18745 
      iprot.readFieldEnd()
18746 
    iprot.readStructEnd()
18747 
 
18748 
  def write(self, oprot):
18749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18751 
      return
18752 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 18753 
    if self.orderId is not None:
2536 chandransh 18754 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18755 
      oprot.writeI64(self.orderId)
18756 
      oprot.writeFieldEnd()
3431 rajveer 18757 
    if self.pickupNumber is not None:
2536 chandransh 18758 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
18759 
      oprot.writeString(self.pickupNumber)
18760 
      oprot.writeFieldEnd()
4602 rajveer 18761 
    if self.providerId is not None:
18762 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
18763 
      oprot.writeI64(self.providerId)
18764 
      oprot.writeFieldEnd()
2536 chandransh 18765 
    oprot.writeFieldStop()
18766 
    oprot.writeStructEnd()
18767 
 
3431 rajveer 18768 
  def validate(self):
18769 
    return
18770 
 
18771 
 
2536 chandransh 18772 
  def __repr__(self):
18773 
    L = ['%s=%r' % (key, value)
18774 
      for key, value in self.__dict__.iteritems()]
18775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18776 
 
18777 
  def __eq__(self, other):
18778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18779 
 
18780 
  def __ne__(self, other):
18781 
    return not (self == other)
18782 
 
18783 
class authorizePickup_result:
18784 
  """
18785 
  Attributes:
18786 
   - success
18787 
   - ex
18788 
  """
18789 
 
18790 
  thrift_spec = (
18791 
    (0, TType.BOOL, 'success', None, None, ), # 0
18792 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18793 
  )
18794 
 
18795 
  def __init__(self, success=None, ex=None,):
18796 
    self.success = success
18797 
    self.ex = ex
18798 
 
18799 
  def read(self, iprot):
18800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18802 
      return
18803 
    iprot.readStructBegin()
18804 
    while True:
18805 
      (fname, ftype, fid) = iprot.readFieldBegin()
18806 
      if ftype == TType.STOP:
18807 
        break
18808 
      if fid == 0:
18809 
        if ftype == TType.BOOL:
18810 
          self.success = iprot.readBool();
18811 
        else:
18812 
          iprot.skip(ftype)
18813 
      elif fid == 1:
18814 
        if ftype == TType.STRUCT:
18815 
          self.ex = TransactionServiceException()
18816 
          self.ex.read(iprot)
18817 
        else:
18818 
          iprot.skip(ftype)
18819 
      else:
18820 
        iprot.skip(ftype)
18821 
      iprot.readFieldEnd()
18822 
    iprot.readStructEnd()
18823 
 
18824 
  def write(self, oprot):
18825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18827 
      return
18828 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18829 
    if self.success is not None:
2536 chandransh 18830 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18831 
      oprot.writeBool(self.success)
18832 
      oprot.writeFieldEnd()
3431 rajveer 18833 
    if self.ex is not None:
2536 chandransh 18834 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18835 
      self.ex.write(oprot)
18836 
      oprot.writeFieldEnd()
18837 
    oprot.writeFieldStop()
18838 
    oprot.writeStructEnd()
18839 
 
3431 rajveer 18840 
  def validate(self):
18841 
    return
18842 
 
18843 
 
2536 chandransh 18844 
  def __repr__(self):
18845 
    L = ['%s=%r' % (key, value)
18846 
      for key, value in self.__dict__.iteritems()]
18847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18848 
 
18849 
  def __eq__(self, other):
18850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18851 
 
18852 
  def __ne__(self, other):
18853 
    return not (self == other)
18854 
 
2764 chandransh 18855 
class markDoasAsPickedUp_args:
18856 
  """
18857 
  Attributes:
18858 
   - providerId
18859 
   - pickupDetails
18860 
  """
18861 
 
18862 
  thrift_spec = (
18863 
    None, # 0
18864 
    (1, TType.I64, 'providerId', None, None, ), # 1
18865 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18866 
  )
18867 
 
18868 
  def __init__(self, providerId=None, pickupDetails=None,):
18869 
    self.providerId = providerId
18870 
    self.pickupDetails = pickupDetails
18871 
 
18872 
  def read(self, iprot):
18873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18875 
      return
18876 
    iprot.readStructBegin()
18877 
    while True:
18878 
      (fname, ftype, fid) = iprot.readFieldBegin()
18879 
      if ftype == TType.STOP:
18880 
        break
18881 
      if fid == 1:
18882 
        if ftype == TType.I64:
18883 
          self.providerId = iprot.readI64();
18884 
        else:
18885 
          iprot.skip(ftype)
18886 
      elif fid == 2:
18887 
        if ftype == TType.MAP:
18888 
          self.pickupDetails = {}
6188 rajveer 18889 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18890 
          for _i411 in xrange(_size407):
18891 
            _key412 = iprot.readString();
18892 
            _val413 = iprot.readString();
18893 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18894 
          iprot.readMapEnd()
18895 
        else:
18896 
          iprot.skip(ftype)
18897 
      else:
18898 
        iprot.skip(ftype)
18899 
      iprot.readFieldEnd()
18900 
    iprot.readStructEnd()
18901 
 
18902 
  def write(self, oprot):
18903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18905 
      return
18906 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18907 
    if self.providerId is not None:
2764 chandransh 18908 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18909 
      oprot.writeI64(self.providerId)
18910 
      oprot.writeFieldEnd()
3431 rajveer 18911 
    if self.pickupDetails is not None:
2764 chandransh 18912 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18913 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18914 
      for kiter414,viter415 in self.pickupDetails.items():
18915 
        oprot.writeString(kiter414)
18916 
        oprot.writeString(viter415)
2764 chandransh 18917 
      oprot.writeMapEnd()
18918 
      oprot.writeFieldEnd()
18919 
    oprot.writeFieldStop()
18920 
    oprot.writeStructEnd()
18921 
 
3431 rajveer 18922 
  def validate(self):
18923 
    return
18924 
 
18925 
 
2764 chandransh 18926 
  def __repr__(self):
18927 
    L = ['%s=%r' % (key, value)
18928 
      for key, value in self.__dict__.iteritems()]
18929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18930 
 
18931 
  def __eq__(self, other):
18932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18933 
 
18934 
  def __ne__(self, other):
18935 
    return not (self == other)
18936 
 
18937 
class markDoasAsPickedUp_result:
4910 phani.kuma 18938 
 
18939 
  thrift_spec = (
18940 
  )
18941 
 
18942 
  def read(self, iprot):
18943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18945 
      return
18946 
    iprot.readStructBegin()
18947 
    while True:
18948 
      (fname, ftype, fid) = iprot.readFieldBegin()
18949 
      if ftype == TType.STOP:
18950 
        break
18951 
      else:
18952 
        iprot.skip(ftype)
18953 
      iprot.readFieldEnd()
18954 
    iprot.readStructEnd()
18955 
 
18956 
  def write(self, oprot):
18957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18959 
      return
18960 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18961 
    oprot.writeFieldStop()
18962 
    oprot.writeStructEnd()
18963 
 
18964 
  def validate(self):
18965 
    return
18966 
 
18967 
 
18968 
  def __repr__(self):
18969 
    L = ['%s=%r' % (key, value)
18970 
      for key, value in self.__dict__.iteritems()]
18971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18972 
 
18973 
  def __eq__(self, other):
18974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18975 
 
18976 
  def __ne__(self, other):
18977 
    return not (self == other)
18978 
 
18979 
class getDoasNotPickedUp_args:
2764 chandransh 18980 
  """
18981 
  Attributes:
4910 phani.kuma 18982 
   - providerId
18983 
  """
18984 
 
18985 
  thrift_spec = (
18986 
    None, # 0
18987 
    (1, TType.I64, 'providerId', None, None, ), # 1
18988 
  )
18989 
 
18990 
  def __init__(self, providerId=None,):
18991 
    self.providerId = providerId
18992 
 
18993 
  def read(self, iprot):
18994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18996 
      return
18997 
    iprot.readStructBegin()
18998 
    while True:
18999 
      (fname, ftype, fid) = iprot.readFieldBegin()
19000 
      if ftype == TType.STOP:
19001 
        break
19002 
      if fid == 1:
19003 
        if ftype == TType.I64:
19004 
          self.providerId = iprot.readI64();
19005 
        else:
19006 
          iprot.skip(ftype)
19007 
      else:
19008 
        iprot.skip(ftype)
19009 
      iprot.readFieldEnd()
19010 
    iprot.readStructEnd()
19011 
 
19012 
  def write(self, oprot):
19013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19015 
      return
19016 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
19017 
    if self.providerId is not None:
19018 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
19019 
      oprot.writeI64(self.providerId)
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 getDoasNotPickedUp_result:
19040 
  """
19041 
  Attributes:
2764 chandransh 19042 
   - success
19043 
  """
19044 
 
19045 
  thrift_spec = (
19046 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19047 
  )
19048 
 
19049 
  def __init__(self, success=None,):
19050 
    self.success = success
19051 
 
19052 
  def read(self, iprot):
19053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19055 
      return
19056 
    iprot.readStructBegin()
19057 
    while True:
19058 
      (fname, ftype, fid) = iprot.readFieldBegin()
19059 
      if ftype == TType.STOP:
19060 
        break
19061 
      if fid == 0:
19062 
        if ftype == TType.LIST:
19063 
          self.success = []
6188 rajveer 19064 
          (_etype419, _size416) = iprot.readListBegin()
19065 
          for _i420 in xrange(_size416):
19066 
            _elem421 = Order()
19067 
            _elem421.read(iprot)
19068 
            self.success.append(_elem421)
2764 chandransh 19069 
          iprot.readListEnd()
19070 
        else:
19071 
          iprot.skip(ftype)
19072 
      else:
19073 
        iprot.skip(ftype)
19074 
      iprot.readFieldEnd()
19075 
    iprot.readStructEnd()
19076 
 
19077 
  def write(self, oprot):
19078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19080 
      return
4910 phani.kuma 19081 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 19082 
    if self.success is not None:
2764 chandransh 19083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19085 
      for iter422 in self.success:
19086 
        iter422.write(oprot)
2764 chandransh 19087 
      oprot.writeListEnd()
19088 
      oprot.writeFieldEnd()
19089 
    oprot.writeFieldStop()
19090 
    oprot.writeStructEnd()
19091 
 
3431 rajveer 19092 
  def validate(self):
19093 
    return
19094 
 
19095 
 
2764 chandransh 19096 
  def __repr__(self):
19097 
    L = ['%s=%r' % (key, value)
19098 
      for key, value in self.__dict__.iteritems()]
19099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19100 
 
19101 
  def __eq__(self, other):
19102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19103 
 
19104 
  def __ne__(self, other):
19105 
    return not (self == other)
19106 
 
4741 phani.kuma 19107 
class markReturnOrdersAsPickedUp_args:
19108 
  """
19109 
  Attributes:
19110 
   - providerId
19111 
   - pickupDetails
19112 
  """
19113 
 
19114 
  thrift_spec = (
19115 
    None, # 0
19116 
    (1, TType.I64, 'providerId', None, None, ), # 1
19117 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
19118 
  )
19119 
 
19120 
  def __init__(self, providerId=None, pickupDetails=None,):
19121 
    self.providerId = providerId
19122 
    self.pickupDetails = pickupDetails
19123 
 
19124 
  def read(self, iprot):
19125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19127 
      return
19128 
    iprot.readStructBegin()
19129 
    while True:
19130 
      (fname, ftype, fid) = iprot.readFieldBegin()
19131 
      if ftype == TType.STOP:
19132 
        break
19133 
      if fid == 1:
19134 
        if ftype == TType.I64:
19135 
          self.providerId = iprot.readI64();
19136 
        else:
19137 
          iprot.skip(ftype)
19138 
      elif fid == 2:
19139 
        if ftype == TType.MAP:
19140 
          self.pickupDetails = {}
6188 rajveer 19141 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
19142 
          for _i427 in xrange(_size423):
19143 
            _key428 = iprot.readString();
19144 
            _val429 = iprot.readString();
19145 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 19146 
          iprot.readMapEnd()
19147 
        else:
19148 
          iprot.skip(ftype)
19149 
      else:
19150 
        iprot.skip(ftype)
19151 
      iprot.readFieldEnd()
19152 
    iprot.readStructEnd()
19153 
 
19154 
  def write(self, oprot):
19155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19157 
      return
19158 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
19159 
    if self.providerId is not None:
19160 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
19161 
      oprot.writeI64(self.providerId)
19162 
      oprot.writeFieldEnd()
19163 
    if self.pickupDetails is not None:
19164 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
19165 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 19166 
      for kiter430,viter431 in self.pickupDetails.items():
19167 
        oprot.writeString(kiter430)
19168 
        oprot.writeString(viter431)
4741 phani.kuma 19169 
      oprot.writeMapEnd()
19170 
      oprot.writeFieldEnd()
19171 
    oprot.writeFieldStop()
19172 
    oprot.writeStructEnd()
19173 
 
19174 
  def validate(self):
19175 
    return
19176 
 
19177 
 
19178 
  def __repr__(self):
19179 
    L = ['%s=%r' % (key, value)
19180 
      for key, value in self.__dict__.iteritems()]
19181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19182 
 
19183 
  def __eq__(self, other):
19184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19185 
 
19186 
  def __ne__(self, other):
19187 
    return not (self == other)
19188 
 
19189 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 19190 
 
19191 
  thrift_spec = (
19192 
  )
19193 
 
19194 
  def read(self, iprot):
19195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19197 
      return
19198 
    iprot.readStructBegin()
19199 
    while True:
19200 
      (fname, ftype, fid) = iprot.readFieldBegin()
19201 
      if ftype == TType.STOP:
19202 
        break
19203 
      else:
19204 
        iprot.skip(ftype)
19205 
      iprot.readFieldEnd()
19206 
    iprot.readStructEnd()
19207 
 
19208 
  def write(self, oprot):
19209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19211 
      return
19212 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
19213 
    oprot.writeFieldStop()
19214 
    oprot.writeStructEnd()
19215 
 
19216 
  def validate(self):
19217 
    return
19218 
 
19219 
 
19220 
  def __repr__(self):
19221 
    L = ['%s=%r' % (key, value)
19222 
      for key, value in self.__dict__.iteritems()]
19223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19224 
 
19225 
  def __eq__(self, other):
19226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19227 
 
19228 
  def __ne__(self, other):
19229 
    return not (self == other)
19230 
 
19231 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 19232 
  """
19233 
  Attributes:
4910 phani.kuma 19234 
   - providerId
19235 
  """
19236 
 
19237 
  thrift_spec = (
19238 
    None, # 0
19239 
    (1, TType.I64, 'providerId', None, None, ), # 1
19240 
  )
19241 
 
19242 
  def __init__(self, providerId=None,):
19243 
    self.providerId = providerId
19244 
 
19245 
  def read(self, iprot):
19246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19248 
      return
19249 
    iprot.readStructBegin()
19250 
    while True:
19251 
      (fname, ftype, fid) = iprot.readFieldBegin()
19252 
      if ftype == TType.STOP:
19253 
        break
19254 
      if fid == 1:
19255 
        if ftype == TType.I64:
19256 
          self.providerId = iprot.readI64();
19257 
        else:
19258 
          iprot.skip(ftype)
19259 
      else:
19260 
        iprot.skip(ftype)
19261 
      iprot.readFieldEnd()
19262 
    iprot.readStructEnd()
19263 
 
19264 
  def write(self, oprot):
19265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19267 
      return
19268 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
19269 
    if self.providerId is not None:
19270 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
19271 
      oprot.writeI64(self.providerId)
19272 
      oprot.writeFieldEnd()
19273 
    oprot.writeFieldStop()
19274 
    oprot.writeStructEnd()
19275 
 
19276 
  def validate(self):
19277 
    return
19278 
 
19279 
 
19280 
  def __repr__(self):
19281 
    L = ['%s=%r' % (key, value)
19282 
      for key, value in self.__dict__.iteritems()]
19283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19284 
 
19285 
  def __eq__(self, other):
19286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19287 
 
19288 
  def __ne__(self, other):
19289 
    return not (self == other)
19290 
 
19291 
class getReturnOrdersNotPickedUp_result:
19292 
  """
19293 
  Attributes:
4741 phani.kuma 19294 
   - success
19295 
  """
19296 
 
19297 
  thrift_spec = (
19298 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19299 
  )
19300 
 
19301 
  def __init__(self, success=None,):
19302 
    self.success = success
19303 
 
19304 
  def read(self, iprot):
19305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19307 
      return
19308 
    iprot.readStructBegin()
19309 
    while True:
19310 
      (fname, ftype, fid) = iprot.readFieldBegin()
19311 
      if ftype == TType.STOP:
19312 
        break
19313 
      if fid == 0:
19314 
        if ftype == TType.LIST:
19315 
          self.success = []
6188 rajveer 19316 
          (_etype435, _size432) = iprot.readListBegin()
19317 
          for _i436 in xrange(_size432):
19318 
            _elem437 = Order()
19319 
            _elem437.read(iprot)
19320 
            self.success.append(_elem437)
4741 phani.kuma 19321 
          iprot.readListEnd()
19322 
        else:
19323 
          iprot.skip(ftype)
19324 
      else:
19325 
        iprot.skip(ftype)
19326 
      iprot.readFieldEnd()
19327 
    iprot.readStructEnd()
19328 
 
19329 
  def write(self, oprot):
19330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19332 
      return
4910 phani.kuma 19333 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 19334 
    if self.success is not None:
19335 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19336 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19337 
      for iter438 in self.success:
19338 
        iter438.write(oprot)
4741 phani.kuma 19339 
      oprot.writeListEnd()
19340 
      oprot.writeFieldEnd()
19341 
    oprot.writeFieldStop()
19342 
    oprot.writeStructEnd()
19343 
 
19344 
  def validate(self):
19345 
    return
19346 
 
19347 
 
19348 
  def __repr__(self):
19349 
    L = ['%s=%r' % (key, value)
19350 
      for key, value in self.__dict__.iteritems()]
19351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19352 
 
19353 
  def __eq__(self, other):
19354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19355 
 
19356 
  def __ne__(self, other):
19357 
    return not (self == other)
19358 
 
2616 chandransh 19359 
class receiveReturn_args:
2591 chandransh 19360 
  """
19361 
  Attributes:
19362 
   - orderId
4479 rajveer 19363 
   - receiveCondition
2591 chandransh 19364 
  """
2536 chandransh 19365 
 
2591 chandransh 19366 
  thrift_spec = (
19367 
    None, # 0
19368 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 19369 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 19370 
  )
19371 
 
4479 rajveer 19372 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 19373 
    self.orderId = orderId
4479 rajveer 19374 
    self.receiveCondition = receiveCondition
2591 chandransh 19375 
 
19376 
  def read(self, iprot):
19377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19379 
      return
19380 
    iprot.readStructBegin()
19381 
    while True:
19382 
      (fname, ftype, fid) = iprot.readFieldBegin()
19383 
      if ftype == TType.STOP:
19384 
        break
19385 
      if fid == 1:
19386 
        if ftype == TType.I64:
19387 
          self.orderId = iprot.readI64();
19388 
        else:
19389 
          iprot.skip(ftype)
4479 rajveer 19390 
      elif fid == 2:
19391 
        if ftype == TType.I64:
19392 
          self.receiveCondition = iprot.readI64();
19393 
        else:
19394 
          iprot.skip(ftype)
2591 chandransh 19395 
      else:
19396 
        iprot.skip(ftype)
19397 
      iprot.readFieldEnd()
19398 
    iprot.readStructEnd()
19399 
 
19400 
  def write(self, oprot):
19401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19403 
      return
2616 chandransh 19404 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 19405 
    if self.orderId is not None:
2591 chandransh 19406 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19407 
      oprot.writeI64(self.orderId)
19408 
      oprot.writeFieldEnd()
4479 rajveer 19409 
    if self.receiveCondition is not None:
19410 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
19411 
      oprot.writeI64(self.receiveCondition)
19412 
      oprot.writeFieldEnd()
2591 chandransh 19413 
    oprot.writeFieldStop()
19414 
    oprot.writeStructEnd()
19415 
 
3431 rajveer 19416 
  def validate(self):
19417 
    return
19418 
 
19419 
 
2591 chandransh 19420 
  def __repr__(self):
19421 
    L = ['%s=%r' % (key, value)
19422 
      for key, value in self.__dict__.iteritems()]
19423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19424 
 
19425 
  def __eq__(self, other):
19426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19427 
 
19428 
  def __ne__(self, other):
19429 
    return not (self == other)
19430 
 
2616 chandransh 19431 
class receiveReturn_result:
2591 chandransh 19432 
  """
19433 
  Attributes:
19434 
   - success
19435 
   - ex
19436 
  """
19437 
 
19438 
  thrift_spec = (
19439 
    (0, TType.BOOL, 'success', None, None, ), # 0
19440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19441 
  )
19442 
 
19443 
  def __init__(self, success=None, ex=None,):
19444 
    self.success = success
19445 
    self.ex = ex
19446 
 
19447 
  def read(self, iprot):
19448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19450 
      return
19451 
    iprot.readStructBegin()
19452 
    while True:
19453 
      (fname, ftype, fid) = iprot.readFieldBegin()
19454 
      if ftype == TType.STOP:
19455 
        break
19456 
      if fid == 0:
19457 
        if ftype == TType.BOOL:
19458 
          self.success = iprot.readBool();
19459 
        else:
19460 
          iprot.skip(ftype)
19461 
      elif fid == 1:
19462 
        if ftype == TType.STRUCT:
19463 
          self.ex = TransactionServiceException()
19464 
          self.ex.read(iprot)
19465 
        else:
19466 
          iprot.skip(ftype)
19467 
      else:
19468 
        iprot.skip(ftype)
19469 
      iprot.readFieldEnd()
19470 
    iprot.readStructEnd()
19471 
 
19472 
  def write(self, oprot):
19473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19475 
      return
2616 chandransh 19476 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 19477 
    if self.success is not None:
2591 chandransh 19478 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19479 
      oprot.writeBool(self.success)
19480 
      oprot.writeFieldEnd()
3431 rajveer 19481 
    if self.ex is not None:
2591 chandransh 19482 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19483 
      self.ex.write(oprot)
19484 
      oprot.writeFieldEnd()
19485 
    oprot.writeFieldStop()
19486 
    oprot.writeStructEnd()
19487 
 
3431 rajveer 19488 
  def validate(self):
19489 
    return
19490 
 
19491 
 
2591 chandransh 19492 
  def __repr__(self):
19493 
    L = ['%s=%r' % (key, value)
19494 
      for key, value in self.__dict__.iteritems()]
19495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19496 
 
19497 
  def __eq__(self, other):
19498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19499 
 
19500 
  def __ne__(self, other):
19501 
    return not (self == other)
19502 
 
19503 
class validateDoa_args:
19504 
  """
19505 
  Attributes:
19506 
   - orderId
19507 
   - isValid
19508 
  """
19509 
 
19510 
  thrift_spec = (
19511 
    None, # 0
19512 
    (1, TType.I64, 'orderId', None, None, ), # 1
19513 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
19514 
  )
19515 
 
19516 
  def __init__(self, orderId=None, isValid=None,):
19517 
    self.orderId = orderId
19518 
    self.isValid = isValid
19519 
 
19520 
  def read(self, iprot):
19521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19523 
      return
19524 
    iprot.readStructBegin()
19525 
    while True:
19526 
      (fname, ftype, fid) = iprot.readFieldBegin()
19527 
      if ftype == TType.STOP:
19528 
        break
19529 
      if fid == 1:
19530 
        if ftype == TType.I64:
19531 
          self.orderId = iprot.readI64();
19532 
        else:
19533 
          iprot.skip(ftype)
19534 
      elif fid == 2:
19535 
        if ftype == TType.BOOL:
19536 
          self.isValid = iprot.readBool();
19537 
        else:
19538 
          iprot.skip(ftype)
19539 
      else:
19540 
        iprot.skip(ftype)
19541 
      iprot.readFieldEnd()
19542 
    iprot.readStructEnd()
19543 
 
19544 
  def write(self, oprot):
19545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19547 
      return
19548 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 19549 
    if self.orderId is not None:
2591 chandransh 19550 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19551 
      oprot.writeI64(self.orderId)
19552 
      oprot.writeFieldEnd()
3431 rajveer 19553 
    if self.isValid is not None:
2591 chandransh 19554 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
19555 
      oprot.writeBool(self.isValid)
19556 
      oprot.writeFieldEnd()
19557 
    oprot.writeFieldStop()
19558 
    oprot.writeStructEnd()
19559 
 
3431 rajveer 19560 
  def validate(self):
19561 
    return
19562 
 
19563 
 
2591 chandransh 19564 
  def __repr__(self):
19565 
    L = ['%s=%r' % (key, value)
19566 
      for key, value in self.__dict__.iteritems()]
19567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19568 
 
19569 
  def __eq__(self, other):
19570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19571 
 
19572 
  def __ne__(self, other):
19573 
    return not (self == other)
19574 
 
19575 
class validateDoa_result:
19576 
  """
19577 
  Attributes:
19578 
   - success
19579 
   - ex
19580 
  """
19581 
 
19582 
  thrift_spec = (
19583 
    (0, TType.BOOL, 'success', None, None, ), # 0
19584 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19585 
  )
19586 
 
19587 
  def __init__(self, success=None, ex=None,):
19588 
    self.success = success
19589 
    self.ex = ex
19590 
 
19591 
  def read(self, iprot):
19592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19594 
      return
19595 
    iprot.readStructBegin()
19596 
    while True:
19597 
      (fname, ftype, fid) = iprot.readFieldBegin()
19598 
      if ftype == TType.STOP:
19599 
        break
19600 
      if fid == 0:
19601 
        if ftype == TType.BOOL:
19602 
          self.success = iprot.readBool();
19603 
        else:
19604 
          iprot.skip(ftype)
19605 
      elif fid == 1:
19606 
        if ftype == TType.STRUCT:
19607 
          self.ex = TransactionServiceException()
19608 
          self.ex.read(iprot)
19609 
        else:
19610 
          iprot.skip(ftype)
19611 
      else:
19612 
        iprot.skip(ftype)
19613 
      iprot.readFieldEnd()
19614 
    iprot.readStructEnd()
19615 
 
19616 
  def write(self, oprot):
19617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19619 
      return
19620 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 19621 
    if self.success is not None:
2591 chandransh 19622 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19623 
      oprot.writeBool(self.success)
19624 
      oprot.writeFieldEnd()
3431 rajveer 19625 
    if self.ex is not None:
2591 chandransh 19626 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19627 
      self.ex.write(oprot)
19628 
      oprot.writeFieldEnd()
19629 
    oprot.writeFieldStop()
19630 
    oprot.writeStructEnd()
19631 
 
3431 rajveer 19632 
  def validate(self):
19633 
    return
19634 
 
19635 
 
2591 chandransh 19636 
  def __repr__(self):
19637 
    L = ['%s=%r' % (key, value)
19638 
      for key, value in self.__dict__.iteritems()]
19639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19640 
 
19641 
  def __eq__(self, other):
19642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19643 
 
19644 
  def __ne__(self, other):
19645 
    return not (self == other)
19646 
 
4495 rajveer 19647 
class validateReturnProduct_args:
19648 
  """
19649 
  Attributes:
19650 
   - orderId
19651 
   - isUsable
19652 
  """
19653 
 
19654 
  thrift_spec = (
19655 
    None, # 0
19656 
    (1, TType.I64, 'orderId', None, None, ), # 1
19657 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
19658 
  )
19659 
 
19660 
  def __init__(self, orderId=None, isUsable=None,):
19661 
    self.orderId = orderId
19662 
    self.isUsable = isUsable
19663 
 
19664 
  def read(self, iprot):
19665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19667 
      return
19668 
    iprot.readStructBegin()
19669 
    while True:
19670 
      (fname, ftype, fid) = iprot.readFieldBegin()
19671 
      if ftype == TType.STOP:
19672 
        break
19673 
      if fid == 1:
19674 
        if ftype == TType.I64:
19675 
          self.orderId = iprot.readI64();
19676 
        else:
19677 
          iprot.skip(ftype)
19678 
      elif fid == 2:
19679 
        if ftype == TType.BOOL:
19680 
          self.isUsable = iprot.readBool();
19681 
        else:
19682 
          iprot.skip(ftype)
19683 
      else:
19684 
        iprot.skip(ftype)
19685 
      iprot.readFieldEnd()
19686 
    iprot.readStructEnd()
19687 
 
19688 
  def write(self, oprot):
19689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19691 
      return
19692 
    oprot.writeStructBegin('validateReturnProduct_args')
19693 
    if self.orderId is not None:
19694 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19695 
      oprot.writeI64(self.orderId)
19696 
      oprot.writeFieldEnd()
19697 
    if self.isUsable is not None:
19698 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
19699 
      oprot.writeBool(self.isUsable)
19700 
      oprot.writeFieldEnd()
19701 
    oprot.writeFieldStop()
19702 
    oprot.writeStructEnd()
19703 
 
19704 
  def validate(self):
19705 
    return
19706 
 
19707 
 
19708 
  def __repr__(self):
19709 
    L = ['%s=%r' % (key, value)
19710 
      for key, value in self.__dict__.iteritems()]
19711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19712 
 
19713 
  def __eq__(self, other):
19714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19715 
 
19716 
  def __ne__(self, other):
19717 
    return not (self == other)
19718 
 
19719 
class validateReturnProduct_result:
19720 
  """
19721 
  Attributes:
19722 
   - success
19723 
   - ex
19724 
  """
19725 
 
19726 
  thrift_spec = (
19727 
    (0, TType.BOOL, 'success', None, None, ), # 0
19728 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19729 
  )
19730 
 
19731 
  def __init__(self, success=None, ex=None,):
19732 
    self.success = success
19733 
    self.ex = ex
19734 
 
19735 
  def read(self, iprot):
19736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19738 
      return
19739 
    iprot.readStructBegin()
19740 
    while True:
19741 
      (fname, ftype, fid) = iprot.readFieldBegin()
19742 
      if ftype == TType.STOP:
19743 
        break
19744 
      if fid == 0:
19745 
        if ftype == TType.BOOL:
19746 
          self.success = iprot.readBool();
19747 
        else:
19748 
          iprot.skip(ftype)
19749 
      elif fid == 1:
19750 
        if ftype == TType.STRUCT:
19751 
          self.ex = TransactionServiceException()
19752 
          self.ex.read(iprot)
19753 
        else:
19754 
          iprot.skip(ftype)
19755 
      else:
19756 
        iprot.skip(ftype)
19757 
      iprot.readFieldEnd()
19758 
    iprot.readStructEnd()
19759 
 
19760 
  def write(self, oprot):
19761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19763 
      return
19764 
    oprot.writeStructBegin('validateReturnProduct_result')
19765 
    if self.success is not None:
19766 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19767 
      oprot.writeBool(self.success)
19768 
      oprot.writeFieldEnd()
19769 
    if self.ex is not None:
19770 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19771 
      self.ex.write(oprot)
19772 
      oprot.writeFieldEnd()
19773 
    oprot.writeFieldStop()
19774 
    oprot.writeStructEnd()
19775 
 
19776 
  def validate(self):
19777 
    return
19778 
 
19779 
 
19780 
  def __repr__(self):
19781 
    L = ['%s=%r' % (key, value)
19782 
      for key, value in self.__dict__.iteritems()]
19783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19784 
 
19785 
  def __eq__(self, other):
19786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19787 
 
19788 
  def __ne__(self, other):
19789 
    return not (self == other)
19790 
 
2616 chandransh 19791 
class reshipOrder_args:
19792 
  """
19793 
  Attributes:
19794 
   - orderId
19795 
  """
2591 chandransh 19796 
 
2616 chandransh 19797 
  thrift_spec = (
19798 
    None, # 0
19799 
    (1, TType.I64, 'orderId', None, None, ), # 1
19800 
  )
19801 
 
19802 
  def __init__(self, orderId=None,):
19803 
    self.orderId = orderId
19804 
 
19805 
  def read(self, iprot):
19806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19808 
      return
19809 
    iprot.readStructBegin()
19810 
    while True:
19811 
      (fname, ftype, fid) = iprot.readFieldBegin()
19812 
      if ftype == TType.STOP:
19813 
        break
19814 
      if fid == 1:
19815 
        if ftype == TType.I64:
19816 
          self.orderId = iprot.readI64();
19817 
        else:
19818 
          iprot.skip(ftype)
19819 
      else:
19820 
        iprot.skip(ftype)
19821 
      iprot.readFieldEnd()
19822 
    iprot.readStructEnd()
19823 
 
19824 
  def write(self, oprot):
19825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19827 
      return
19828 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19829 
    if self.orderId is not None:
2616 chandransh 19830 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19831 
      oprot.writeI64(self.orderId)
19832 
      oprot.writeFieldEnd()
19833 
    oprot.writeFieldStop()
19834 
    oprot.writeStructEnd()
19835 
 
3431 rajveer 19836 
  def validate(self):
19837 
    return
19838 
 
19839 
 
2616 chandransh 19840 
  def __repr__(self):
19841 
    L = ['%s=%r' % (key, value)
19842 
      for key, value in self.__dict__.iteritems()]
19843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19844 
 
19845 
  def __eq__(self, other):
19846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19847 
 
19848 
  def __ne__(self, other):
19849 
    return not (self == other)
19850 
 
19851 
class reshipOrder_result:
19852 
  """
19853 
  Attributes:
19854 
   - success
19855 
   - ex
19856 
  """
19857 
 
19858 
  thrift_spec = (
19859 
    (0, TType.I64, 'success', None, None, ), # 0
19860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19861 
  )
19862 
 
19863 
  def __init__(self, success=None, ex=None,):
19864 
    self.success = success
19865 
    self.ex = ex
19866 
 
19867 
  def read(self, iprot):
19868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19870 
      return
19871 
    iprot.readStructBegin()
19872 
    while True:
19873 
      (fname, ftype, fid) = iprot.readFieldBegin()
19874 
      if ftype == TType.STOP:
19875 
        break
19876 
      if fid == 0:
19877 
        if ftype == TType.I64:
19878 
          self.success = iprot.readI64();
19879 
        else:
19880 
          iprot.skip(ftype)
19881 
      elif fid == 1:
19882 
        if ftype == TType.STRUCT:
19883 
          self.ex = TransactionServiceException()
19884 
          self.ex.read(iprot)
19885 
        else:
19886 
          iprot.skip(ftype)
19887 
      else:
19888 
        iprot.skip(ftype)
19889 
      iprot.readFieldEnd()
19890 
    iprot.readStructEnd()
19891 
 
19892 
  def write(self, oprot):
19893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19895 
      return
19896 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19897 
    if self.success is not None:
2616 chandransh 19898 
      oprot.writeFieldBegin('success', TType.I64, 0)
19899 
      oprot.writeI64(self.success)
19900 
      oprot.writeFieldEnd()
3431 rajveer 19901 
    if self.ex is not None:
2616 chandransh 19902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19903 
      self.ex.write(oprot)
19904 
      oprot.writeFieldEnd()
19905 
    oprot.writeFieldStop()
19906 
    oprot.writeStructEnd()
19907 
 
3431 rajveer 19908 
  def validate(self):
19909 
    return
19910 
 
19911 
 
2616 chandransh 19912 
  def __repr__(self):
19913 
    L = ['%s=%r' % (key, value)
19914 
      for key, value in self.__dict__.iteritems()]
19915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19916 
 
19917 
  def __eq__(self, other):
19918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19919 
 
19920 
  def __ne__(self, other):
19921 
    return not (self == other)
19922 
 
19923 
class refundOrder_args:
19924 
  """
19925 
  Attributes:
19926 
   - orderId
3226 chandransh 19927 
   - refundedBy
19928 
   - reason
2616 chandransh 19929 
  """
19930 
 
19931 
  thrift_spec = (
19932 
    None, # 0
19933 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19934 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19935 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19936 
  )
19937 
 
3226 chandransh 19938 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19939 
    self.orderId = orderId
3226 chandransh 19940 
    self.refundedBy = refundedBy
19941 
    self.reason = reason
2616 chandransh 19942 
 
19943 
  def read(self, iprot):
19944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19946 
      return
19947 
    iprot.readStructBegin()
19948 
    while True:
19949 
      (fname, ftype, fid) = iprot.readFieldBegin()
19950 
      if ftype == TType.STOP:
19951 
        break
19952 
      if fid == 1:
19953 
        if ftype == TType.I64:
19954 
          self.orderId = iprot.readI64();
19955 
        else:
19956 
          iprot.skip(ftype)
3226 chandransh 19957 
      elif fid == 2:
19958 
        if ftype == TType.STRING:
19959 
          self.refundedBy = iprot.readString();
19960 
        else:
19961 
          iprot.skip(ftype)
19962 
      elif fid == 3:
19963 
        if ftype == TType.STRING:
19964 
          self.reason = iprot.readString();
19965 
        else:
19966 
          iprot.skip(ftype)
2616 chandransh 19967 
      else:
19968 
        iprot.skip(ftype)
19969 
      iprot.readFieldEnd()
19970 
    iprot.readStructEnd()
19971 
 
19972 
  def write(self, oprot):
19973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19975 
      return
19976 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19977 
    if self.orderId is not None:
2616 chandransh 19978 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19979 
      oprot.writeI64(self.orderId)
19980 
      oprot.writeFieldEnd()
3431 rajveer 19981 
    if self.refundedBy is not None:
3226 chandransh 19982 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19983 
      oprot.writeString(self.refundedBy)
19984 
      oprot.writeFieldEnd()
3431 rajveer 19985 
    if self.reason is not None:
3226 chandransh 19986 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19987 
      oprot.writeString(self.reason)
19988 
      oprot.writeFieldEnd()
2616 chandransh 19989 
    oprot.writeFieldStop()
19990 
    oprot.writeStructEnd()
19991 
 
3431 rajveer 19992 
  def validate(self):
19993 
    return
19994 
 
19995 
 
2616 chandransh 19996 
  def __repr__(self):
19997 
    L = ['%s=%r' % (key, value)
19998 
      for key, value in self.__dict__.iteritems()]
19999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20000 
 
20001 
  def __eq__(self, other):
20002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20003 
 
20004 
  def __ne__(self, other):
20005 
    return not (self == other)
20006 
 
20007 
class refundOrder_result:
20008 
  """
20009 
  Attributes:
20010 
   - success
20011 
   - ex
20012 
  """
20013 
 
20014 
  thrift_spec = (
20015 
    (0, TType.BOOL, 'success', None, None, ), # 0
20016 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20017 
  )
20018 
 
20019 
  def __init__(self, success=None, ex=None,):
20020 
    self.success = success
20021 
    self.ex = ex
20022 
 
20023 
  def read(self, iprot):
20024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20026 
      return
20027 
    iprot.readStructBegin()
20028 
    while True:
20029 
      (fname, ftype, fid) = iprot.readFieldBegin()
20030 
      if ftype == TType.STOP:
20031 
        break
20032 
      if fid == 0:
20033 
        if ftype == TType.BOOL:
20034 
          self.success = iprot.readBool();
20035 
        else:
20036 
          iprot.skip(ftype)
20037 
      elif fid == 1:
20038 
        if ftype == TType.STRUCT:
20039 
          self.ex = TransactionServiceException()
20040 
          self.ex.read(iprot)
20041 
        else:
20042 
          iprot.skip(ftype)
20043 
      else:
20044 
        iprot.skip(ftype)
20045 
      iprot.readFieldEnd()
20046 
    iprot.readStructEnd()
20047 
 
20048 
  def write(self, oprot):
20049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20051 
      return
20052 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 20053 
    if self.success is not None:
2616 chandransh 20054 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20055 
      oprot.writeBool(self.success)
20056 
      oprot.writeFieldEnd()
3431 rajveer 20057 
    if self.ex is not None:
2616 chandransh 20058 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20059 
      self.ex.write(oprot)
20060 
      oprot.writeFieldEnd()
20061 
    oprot.writeFieldStop()
20062 
    oprot.writeStructEnd()
20063 
 
3431 rajveer 20064 
  def validate(self):
20065 
    return
20066 
 
20067 
 
2616 chandransh 20068 
  def __repr__(self):
20069 
    L = ['%s=%r' % (key, value)
20070 
      for key, value in self.__dict__.iteritems()]
20071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20072 
 
20073 
  def __eq__(self, other):
20074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20075 
 
20076 
  def __ne__(self, other):
20077 
    return not (self == other)
20078 
 
2690 chandransh 20079 
class getReturnOrders_args:
20080 
  """
20081 
  Attributes:
20082 
   - warehouseId
20083 
   - fromDate
20084 
   - toDate
20085 
  """
2616 chandransh 20086 
 
2690 chandransh 20087 
  thrift_spec = (
20088 
    None, # 0
20089 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
20090 
    (2, TType.I64, 'fromDate', None, None, ), # 2
20091 
    (3, TType.I64, 'toDate', None, None, ), # 3
20092 
  )
20093 
 
20094 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
20095 
    self.warehouseId = warehouseId
20096 
    self.fromDate = fromDate
20097 
    self.toDate = toDate
20098 
 
20099 
  def read(self, iprot):
20100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20102 
      return
20103 
    iprot.readStructBegin()
20104 
    while True:
20105 
      (fname, ftype, fid) = iprot.readFieldBegin()
20106 
      if ftype == TType.STOP:
20107 
        break
20108 
      if fid == 1:
20109 
        if ftype == TType.I64:
20110 
          self.warehouseId = iprot.readI64();
20111 
        else:
20112 
          iprot.skip(ftype)
20113 
      elif fid == 2:
20114 
        if ftype == TType.I64:
20115 
          self.fromDate = iprot.readI64();
20116 
        else:
20117 
          iprot.skip(ftype)
20118 
      elif fid == 3:
20119 
        if ftype == TType.I64:
20120 
          self.toDate = iprot.readI64();
20121 
        else:
20122 
          iprot.skip(ftype)
20123 
      else:
20124 
        iprot.skip(ftype)
20125 
      iprot.readFieldEnd()
20126 
    iprot.readStructEnd()
20127 
 
20128 
  def write(self, oprot):
20129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20131 
      return
20132 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 20133 
    if self.warehouseId is not None:
2690 chandransh 20134 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
20135 
      oprot.writeI64(self.warehouseId)
20136 
      oprot.writeFieldEnd()
3431 rajveer 20137 
    if self.fromDate is not None:
2690 chandransh 20138 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
20139 
      oprot.writeI64(self.fromDate)
20140 
      oprot.writeFieldEnd()
3431 rajveer 20141 
    if self.toDate is not None:
2690 chandransh 20142 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
20143 
      oprot.writeI64(self.toDate)
20144 
      oprot.writeFieldEnd()
20145 
    oprot.writeFieldStop()
20146 
    oprot.writeStructEnd()
20147 
 
3431 rajveer 20148 
  def validate(self):
20149 
    return
20150 
 
20151 
 
2690 chandransh 20152 
  def __repr__(self):
20153 
    L = ['%s=%r' % (key, value)
20154 
      for key, value in self.__dict__.iteritems()]
20155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20156 
 
20157 
  def __eq__(self, other):
20158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20159 
 
20160 
  def __ne__(self, other):
20161 
    return not (self == other)
20162 
 
20163 
class getReturnOrders_result:
20164 
  """
20165 
  Attributes:
20166 
   - success
20167 
  """
20168 
 
20169 
  thrift_spec = (
20170 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
20171 
  )
20172 
 
20173 
  def __init__(self, success=None,):
20174 
    self.success = success
20175 
 
20176 
  def read(self, iprot):
20177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20179 
      return
20180 
    iprot.readStructBegin()
20181 
    while True:
20182 
      (fname, ftype, fid) = iprot.readFieldBegin()
20183 
      if ftype == TType.STOP:
20184 
        break
20185 
      if fid == 0:
20186 
        if ftype == TType.LIST:
20187 
          self.success = []
6188 rajveer 20188 
          (_etype442, _size439) = iprot.readListBegin()
20189 
          for _i443 in xrange(_size439):
20190 
            _elem444 = ReturnOrder()
20191 
            _elem444.read(iprot)
20192 
            self.success.append(_elem444)
2690 chandransh 20193 
          iprot.readListEnd()
20194 
        else:
20195 
          iprot.skip(ftype)
20196 
      else:
20197 
        iprot.skip(ftype)
20198 
      iprot.readFieldEnd()
20199 
    iprot.readStructEnd()
20200 
 
20201 
  def write(self, oprot):
20202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20204 
      return
20205 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 20206 
    if self.success is not None:
2690 chandransh 20207 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20208 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20209 
      for iter445 in self.success:
20210 
        iter445.write(oprot)
2690 chandransh 20211 
      oprot.writeListEnd()
20212 
      oprot.writeFieldEnd()
20213 
    oprot.writeFieldStop()
20214 
    oprot.writeStructEnd()
20215 
 
3431 rajveer 20216 
  def validate(self):
20217 
    return
20218 
 
20219 
 
2690 chandransh 20220 
  def __repr__(self):
20221 
    L = ['%s=%r' % (key, value)
20222 
      for key, value in self.__dict__.iteritems()]
20223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20224 
 
20225 
  def __eq__(self, other):
20226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20227 
 
20228 
  def __ne__(self, other):
20229 
    return not (self == other)
20230 
 
5481 phani.kuma 20231 
class getAllReturnOrders_args:
20232 
  """
20233 
  Attributes:
20234 
   - onlyNotProcessed
20235 
   - fromDate
20236 
   - toDate
20237 
  """
20238 
 
20239 
  thrift_spec = (
20240 
    None, # 0
20241 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
20242 
    (2, TType.I64, 'fromDate', None, None, ), # 2
20243 
    (3, TType.I64, 'toDate', None, None, ), # 3
20244 
  )
20245 
 
20246 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
20247 
    self.onlyNotProcessed = onlyNotProcessed
20248 
    self.fromDate = fromDate
20249 
    self.toDate = toDate
20250 
 
20251 
  def read(self, iprot):
20252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20254 
      return
20255 
    iprot.readStructBegin()
20256 
    while True:
20257 
      (fname, ftype, fid) = iprot.readFieldBegin()
20258 
      if ftype == TType.STOP:
20259 
        break
20260 
      if fid == 1:
20261 
        if ftype == TType.BOOL:
20262 
          self.onlyNotProcessed = iprot.readBool();
20263 
        else:
20264 
          iprot.skip(ftype)
20265 
      elif fid == 2:
20266 
        if ftype == TType.I64:
20267 
          self.fromDate = iprot.readI64();
20268 
        else:
20269 
          iprot.skip(ftype)
20270 
      elif fid == 3:
20271 
        if ftype == TType.I64:
20272 
          self.toDate = iprot.readI64();
20273 
        else:
20274 
          iprot.skip(ftype)
20275 
      else:
20276 
        iprot.skip(ftype)
20277 
      iprot.readFieldEnd()
20278 
    iprot.readStructEnd()
20279 
 
20280 
  def write(self, oprot):
20281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20283 
      return
20284 
    oprot.writeStructBegin('getAllReturnOrders_args')
20285 
    if self.onlyNotProcessed is not None:
20286 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
20287 
      oprot.writeBool(self.onlyNotProcessed)
20288 
      oprot.writeFieldEnd()
20289 
    if self.fromDate is not None:
20290 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
20291 
      oprot.writeI64(self.fromDate)
20292 
      oprot.writeFieldEnd()
20293 
    if self.toDate is not None:
20294 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
20295 
      oprot.writeI64(self.toDate)
20296 
      oprot.writeFieldEnd()
20297 
    oprot.writeFieldStop()
20298 
    oprot.writeStructEnd()
20299 
 
20300 
  def validate(self):
20301 
    return
20302 
 
20303 
 
20304 
  def __repr__(self):
20305 
    L = ['%s=%r' % (key, value)
20306 
      for key, value in self.__dict__.iteritems()]
20307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20308 
 
20309 
  def __eq__(self, other):
20310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20311 
 
20312 
  def __ne__(self, other):
20313 
    return not (self == other)
20314 
 
20315 
class getAllReturnOrders_result:
20316 
  """
20317 
  Attributes:
20318 
   - success
20319 
  """
20320 
 
20321 
  thrift_spec = (
20322 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
20323 
  )
20324 
 
20325 
  def __init__(self, success=None,):
20326 
    self.success = success
20327 
 
20328 
  def read(self, iprot):
20329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20331 
      return
20332 
    iprot.readStructBegin()
20333 
    while True:
20334 
      (fname, ftype, fid) = iprot.readFieldBegin()
20335 
      if ftype == TType.STOP:
20336 
        break
20337 
      if fid == 0:
20338 
        if ftype == TType.LIST:
20339 
          self.success = []
6188 rajveer 20340 
          (_etype449, _size446) = iprot.readListBegin()
20341 
          for _i450 in xrange(_size446):
20342 
            _elem451 = ReturnOrder()
20343 
            _elem451.read(iprot)
20344 
            self.success.append(_elem451)
5481 phani.kuma 20345 
          iprot.readListEnd()
20346 
        else:
20347 
          iprot.skip(ftype)
20348 
      else:
20349 
        iprot.skip(ftype)
20350 
      iprot.readFieldEnd()
20351 
    iprot.readStructEnd()
20352 
 
20353 
  def write(self, oprot):
20354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20356 
      return
20357 
    oprot.writeStructBegin('getAllReturnOrders_result')
20358 
    if self.success is not None:
20359 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20360 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20361 
      for iter452 in self.success:
20362 
        iter452.write(oprot)
5481 phani.kuma 20363 
      oprot.writeListEnd()
20364 
      oprot.writeFieldEnd()
20365 
    oprot.writeFieldStop()
20366 
    oprot.writeStructEnd()
20367 
 
20368 
  def validate(self):
20369 
    return
20370 
 
20371 
 
20372 
  def __repr__(self):
20373 
    L = ['%s=%r' % (key, value)
20374 
      for key, value in self.__dict__.iteritems()]
20375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20376 
 
20377 
  def __eq__(self, other):
20378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20379 
 
20380 
  def __ne__(self, other):
20381 
    return not (self == other)
20382 
 
2700 chandransh 20383 
class getReturnOrder_args:
20384 
  """
20385 
  Attributes:
20386 
   - id
20387 
  """
20388 
 
20389 
  thrift_spec = (
20390 
    None, # 0
20391 
    (1, TType.I64, 'id', None, None, ), # 1
20392 
  )
20393 
 
20394 
  def __init__(self, id=None,):
20395 
    self.id = id
20396 
 
20397 
  def read(self, iprot):
20398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20400 
      return
20401 
    iprot.readStructBegin()
20402 
    while True:
20403 
      (fname, ftype, fid) = iprot.readFieldBegin()
20404 
      if ftype == TType.STOP:
20405 
        break
20406 
      if fid == 1:
20407 
        if ftype == TType.I64:
20408 
          self.id = iprot.readI64();
20409 
        else:
20410 
          iprot.skip(ftype)
20411 
      else:
20412 
        iprot.skip(ftype)
20413 
      iprot.readFieldEnd()
20414 
    iprot.readStructEnd()
20415 
 
20416 
  def write(self, oprot):
20417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20419 
      return
20420 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 20421 
    if self.id is not None:
2700 chandransh 20422 
      oprot.writeFieldBegin('id', TType.I64, 1)
20423 
      oprot.writeI64(self.id)
20424 
      oprot.writeFieldEnd()
20425 
    oprot.writeFieldStop()
20426 
    oprot.writeStructEnd()
20427 
 
3431 rajveer 20428 
  def validate(self):
20429 
    return
20430 
 
20431 
 
2700 chandransh 20432 
  def __repr__(self):
20433 
    L = ['%s=%r' % (key, value)
20434 
      for key, value in self.__dict__.iteritems()]
20435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20436 
 
20437 
  def __eq__(self, other):
20438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20439 
 
20440 
  def __ne__(self, other):
20441 
    return not (self == other)
20442 
 
20443 
class getReturnOrder_result:
20444 
  """
20445 
  Attributes:
20446 
   - success
20447 
   - ex
20448 
  """
20449 
 
20450 
  thrift_spec = (
20451 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
20452 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20453 
  )
20454 
 
20455 
  def __init__(self, success=None, ex=None,):
20456 
    self.success = success
20457 
    self.ex = ex
20458 
 
20459 
  def read(self, iprot):
20460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20462 
      return
20463 
    iprot.readStructBegin()
20464 
    while True:
20465 
      (fname, ftype, fid) = iprot.readFieldBegin()
20466 
      if ftype == TType.STOP:
20467 
        break
20468 
      if fid == 0:
20469 
        if ftype == TType.STRUCT:
20470 
          self.success = ReturnOrder()
20471 
          self.success.read(iprot)
20472 
        else:
20473 
          iprot.skip(ftype)
20474 
      elif fid == 1:
20475 
        if ftype == TType.STRUCT:
20476 
          self.ex = TransactionServiceException()
20477 
          self.ex.read(iprot)
20478 
        else:
20479 
          iprot.skip(ftype)
20480 
      else:
20481 
        iprot.skip(ftype)
20482 
      iprot.readFieldEnd()
20483 
    iprot.readStructEnd()
20484 
 
20485 
  def write(self, oprot):
20486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20488 
      return
20489 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 20490 
    if self.success is not None:
2700 chandransh 20491 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20492 
      self.success.write(oprot)
20493 
      oprot.writeFieldEnd()
3431 rajveer 20494 
    if self.ex is not None:
2700 chandransh 20495 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20496 
      self.ex.write(oprot)
20497 
      oprot.writeFieldEnd()
20498 
    oprot.writeFieldStop()
20499 
    oprot.writeStructEnd()
20500 
 
3431 rajveer 20501 
  def validate(self):
20502 
    return
20503 
 
20504 
 
2700 chandransh 20505 
  def __repr__(self):
20506 
    L = ['%s=%r' % (key, value)
20507 
      for key, value in self.__dict__.iteritems()]
20508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20509 
 
20510 
  def __eq__(self, other):
20511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20512 
 
20513 
  def __ne__(self, other):
20514 
    return not (self == other)
20515 
 
2690 chandransh 20516 
class processReturn_args:
20517 
  """
20518 
  Attributes:
20519 
   - returnOrderId
20520 
  """
20521 
 
20522 
  thrift_spec = (
20523 
    None, # 0
20524 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
20525 
  )
20526 
 
20527 
  def __init__(self, returnOrderId=None,):
20528 
    self.returnOrderId = returnOrderId
20529 
 
20530 
  def read(self, iprot):
20531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20533 
      return
20534 
    iprot.readStructBegin()
20535 
    while True:
20536 
      (fname, ftype, fid) = iprot.readFieldBegin()
20537 
      if ftype == TType.STOP:
20538 
        break
20539 
      if fid == 1:
20540 
        if ftype == TType.I64:
20541 
          self.returnOrderId = iprot.readI64();
20542 
        else:
20543 
          iprot.skip(ftype)
20544 
      else:
20545 
        iprot.skip(ftype)
20546 
      iprot.readFieldEnd()
20547 
    iprot.readStructEnd()
20548 
 
20549 
  def write(self, oprot):
20550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20552 
      return
20553 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 20554 
    if self.returnOrderId is not None:
2690 chandransh 20555 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
20556 
      oprot.writeI64(self.returnOrderId)
20557 
      oprot.writeFieldEnd()
20558 
    oprot.writeFieldStop()
20559 
    oprot.writeStructEnd()
20560 
 
3431 rajveer 20561 
  def validate(self):
20562 
    return
20563 
 
20564 
 
2690 chandransh 20565 
  def __repr__(self):
20566 
    L = ['%s=%r' % (key, value)
20567 
      for key, value in self.__dict__.iteritems()]
20568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20569 
 
20570 
  def __eq__(self, other):
20571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20572 
 
20573 
  def __ne__(self, other):
20574 
    return not (self == other)
20575 
 
20576 
class processReturn_result:
20577 
  """
20578 
  Attributes:
20579 
   - ex
20580 
  """
20581 
 
20582 
  thrift_spec = (
20583 
    None, # 0
20584 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20585 
  )
20586 
 
20587 
  def __init__(self, ex=None,):
20588 
    self.ex = ex
20589 
 
20590 
  def read(self, iprot):
20591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20593 
      return
20594 
    iprot.readStructBegin()
20595 
    while True:
20596 
      (fname, ftype, fid) = iprot.readFieldBegin()
20597 
      if ftype == TType.STOP:
20598 
        break
20599 
      if fid == 1:
20600 
        if ftype == TType.STRUCT:
20601 
          self.ex = TransactionServiceException()
20602 
          self.ex.read(iprot)
20603 
        else:
20604 
          iprot.skip(ftype)
20605 
      else:
20606 
        iprot.skip(ftype)
20607 
      iprot.readFieldEnd()
20608 
    iprot.readStructEnd()
20609 
 
20610 
  def write(self, oprot):
20611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20613 
      return
20614 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 20615 
    if self.ex is not None:
2690 chandransh 20616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20617 
      self.ex.write(oprot)
20618 
      oprot.writeFieldEnd()
20619 
    oprot.writeFieldStop()
20620 
    oprot.writeStructEnd()
20621 
 
3431 rajveer 20622 
  def validate(self):
20623 
    return
20624 
 
20625 
 
2690 chandransh 20626 
  def __repr__(self):
20627 
    L = ['%s=%r' % (key, value)
20628 
      for key, value in self.__dict__.iteritems()]
20629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20630 
 
20631 
  def __eq__(self, other):
20632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20633 
 
20634 
  def __ne__(self, other):
20635 
    return not (self == other)
20636 
 
3451 chandransh 20637 
class updateWeight_args:
20638 
  """
20639 
  Attributes:
20640 
   - orderId
20641 
   - weight
20642 
  """
20643 
 
20644 
  thrift_spec = (
20645 
    None, # 0
20646 
    (1, TType.I64, 'orderId', None, None, ), # 1
20647 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
20648 
  )
20649 
 
20650 
  def __init__(self, orderId=None, weight=None,):
20651 
    self.orderId = orderId
20652 
    self.weight = weight
20653 
 
20654 
  def read(self, iprot):
20655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20657 
      return
20658 
    iprot.readStructBegin()
20659 
    while True:
20660 
      (fname, ftype, fid) = iprot.readFieldBegin()
20661 
      if ftype == TType.STOP:
20662 
        break
20663 
      if fid == 1:
20664 
        if ftype == TType.I64:
20665 
          self.orderId = iprot.readI64();
20666 
        else:
20667 
          iprot.skip(ftype)
20668 
      elif fid == 2:
20669 
        if ftype == TType.DOUBLE:
20670 
          self.weight = iprot.readDouble();
20671 
        else:
20672 
          iprot.skip(ftype)
20673 
      else:
20674 
        iprot.skip(ftype)
20675 
      iprot.readFieldEnd()
20676 
    iprot.readStructEnd()
20677 
 
20678 
  def write(self, oprot):
20679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20681 
      return
20682 
    oprot.writeStructBegin('updateWeight_args')
20683 
    if self.orderId is not None:
20684 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20685 
      oprot.writeI64(self.orderId)
20686 
      oprot.writeFieldEnd()
20687 
    if self.weight is not None:
20688 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
20689 
      oprot.writeDouble(self.weight)
20690 
      oprot.writeFieldEnd()
20691 
    oprot.writeFieldStop()
20692 
    oprot.writeStructEnd()
20693 
 
20694 
  def validate(self):
20695 
    return
20696 
 
20697 
 
20698 
  def __repr__(self):
20699 
    L = ['%s=%r' % (key, value)
20700 
      for key, value in self.__dict__.iteritems()]
20701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20702 
 
20703 
  def __eq__(self, other):
20704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20705 
 
20706 
  def __ne__(self, other):
20707 
    return not (self == other)
20708 
 
20709 
class updateWeight_result:
20710 
  """
20711 
  Attributes:
20712 
   - success
20713 
   - ex
20714 
  """
20715 
 
20716 
  thrift_spec = (
20717 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20718 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20719 
  )
20720 
 
20721 
  def __init__(self, success=None, ex=None,):
20722 
    self.success = success
20723 
    self.ex = ex
20724 
 
20725 
  def read(self, iprot):
20726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20728 
      return
20729 
    iprot.readStructBegin()
20730 
    while True:
20731 
      (fname, ftype, fid) = iprot.readFieldBegin()
20732 
      if ftype == TType.STOP:
20733 
        break
20734 
      if fid == 0:
20735 
        if ftype == TType.STRUCT:
20736 
          self.success = Order()
20737 
          self.success.read(iprot)
20738 
        else:
20739 
          iprot.skip(ftype)
20740 
      elif fid == 1:
20741 
        if ftype == TType.STRUCT:
20742 
          self.ex = TransactionServiceException()
20743 
          self.ex.read(iprot)
20744 
        else:
20745 
          iprot.skip(ftype)
20746 
      else:
20747 
        iprot.skip(ftype)
20748 
      iprot.readFieldEnd()
20749 
    iprot.readStructEnd()
20750 
 
20751 
  def write(self, oprot):
20752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20754 
      return
20755 
    oprot.writeStructBegin('updateWeight_result')
20756 
    if self.success is not None:
20757 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20758 
      self.success.write(oprot)
20759 
      oprot.writeFieldEnd()
20760 
    if self.ex is not None:
20761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20762 
      self.ex.write(oprot)
20763 
      oprot.writeFieldEnd()
20764 
    oprot.writeFieldStop()
20765 
    oprot.writeStructEnd()
20766 
 
20767 
  def validate(self):
20768 
    return
20769 
 
20770 
 
20771 
  def __repr__(self):
20772 
    L = ['%s=%r' % (key, value)
20773 
      for key, value in self.__dict__.iteritems()]
20774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20775 
 
20776 
  def __eq__(self, other):
20777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20778 
 
20779 
  def __ne__(self, other):
20780 
    return not (self == other)
3469 chandransh 20781 
 
20782 
class changeItem_args:
20783 
  """
20784 
  Attributes:
20785 
   - orderId
20786 
   - itemId
20787 
  """
20788 
 
20789 
  thrift_spec = (
20790 
    None, # 0
20791 
    (1, TType.I64, 'orderId', None, None, ), # 1
20792 
    (2, TType.I64, 'itemId', None, None, ), # 2
20793 
  )
20794 
 
20795 
  def __init__(self, orderId=None, itemId=None,):
20796 
    self.orderId = orderId
20797 
    self.itemId = itemId
20798 
 
20799 
  def read(self, iprot):
20800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20802 
      return
20803 
    iprot.readStructBegin()
20804 
    while True:
20805 
      (fname, ftype, fid) = iprot.readFieldBegin()
20806 
      if ftype == TType.STOP:
20807 
        break
20808 
      if fid == 1:
20809 
        if ftype == TType.I64:
20810 
          self.orderId = iprot.readI64();
20811 
        else:
20812 
          iprot.skip(ftype)
20813 
      elif fid == 2:
20814 
        if ftype == TType.I64:
20815 
          self.itemId = iprot.readI64();
20816 
        else:
20817 
          iprot.skip(ftype)
20818 
      else:
20819 
        iprot.skip(ftype)
20820 
      iprot.readFieldEnd()
20821 
    iprot.readStructEnd()
20822 
 
20823 
  def write(self, oprot):
20824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20826 
      return
20827 
    oprot.writeStructBegin('changeItem_args')
20828 
    if self.orderId is not None:
20829 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20830 
      oprot.writeI64(self.orderId)
20831 
      oprot.writeFieldEnd()
20832 
    if self.itemId is not None:
20833 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20834 
      oprot.writeI64(self.itemId)
20835 
      oprot.writeFieldEnd()
20836 
    oprot.writeFieldStop()
20837 
    oprot.writeStructEnd()
20838 
 
20839 
  def validate(self):
20840 
    return
20841 
 
20842 
 
20843 
  def __repr__(self):
20844 
    L = ['%s=%r' % (key, value)
20845 
      for key, value in self.__dict__.iteritems()]
20846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20847 
 
20848 
  def __eq__(self, other):
20849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20850 
 
20851 
  def __ne__(self, other):
20852 
    return not (self == other)
20853 
 
20854 
class changeItem_result:
20855 
  """
20856 
  Attributes:
20857 
   - success
20858 
   - ex
20859 
  """
20860 
 
20861 
  thrift_spec = (
20862 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20864 
  )
20865 
 
20866 
  def __init__(self, success=None, ex=None,):
20867 
    self.success = success
20868 
    self.ex = ex
20869 
 
20870 
  def read(self, iprot):
20871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20873 
      return
20874 
    iprot.readStructBegin()
20875 
    while True:
20876 
      (fname, ftype, fid) = iprot.readFieldBegin()
20877 
      if ftype == TType.STOP:
20878 
        break
20879 
      if fid == 0:
20880 
        if ftype == TType.STRUCT:
20881 
          self.success = Order()
20882 
          self.success.read(iprot)
20883 
        else:
20884 
          iprot.skip(ftype)
20885 
      elif fid == 1:
20886 
        if ftype == TType.STRUCT:
20887 
          self.ex = TransactionServiceException()
20888 
          self.ex.read(iprot)
20889 
        else:
20890 
          iprot.skip(ftype)
20891 
      else:
20892 
        iprot.skip(ftype)
20893 
      iprot.readFieldEnd()
20894 
    iprot.readStructEnd()
20895 
 
20896 
  def write(self, oprot):
20897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20899 
      return
20900 
    oprot.writeStructBegin('changeItem_result')
20901 
    if self.success is not None:
20902 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20903 
      self.success.write(oprot)
20904 
      oprot.writeFieldEnd()
20905 
    if self.ex is not None:
20906 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20907 
      self.ex.write(oprot)
20908 
      oprot.writeFieldEnd()
20909 
    oprot.writeFieldStop()
20910 
    oprot.writeStructEnd()
20911 
 
20912 
  def validate(self):
20913 
    return
20914 
 
20915 
 
20916 
  def __repr__(self):
20917 
    L = ['%s=%r' % (key, value)
20918 
      for key, value in self.__dict__.iteritems()]
20919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20920 
 
20921 
  def __eq__(self, other):
20922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20923 
 
20924 
  def __ne__(self, other):
20925 
    return not (self == other)
20926 
 
20927 
class shiftToWarehouse_args:
20928 
  """
20929 
  Attributes:
20930 
   - orderId
20931 
   - warehouseId
20932 
  """
20933 
 
20934 
  thrift_spec = (
20935 
    None, # 0
20936 
    (1, TType.I64, 'orderId', None, None, ), # 1
20937 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20938 
  )
20939 
 
20940 
  def __init__(self, orderId=None, warehouseId=None,):
20941 
    self.orderId = orderId
20942 
    self.warehouseId = warehouseId
20943 
 
20944 
  def read(self, iprot):
20945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20947 
      return
20948 
    iprot.readStructBegin()
20949 
    while True:
20950 
      (fname, ftype, fid) = iprot.readFieldBegin()
20951 
      if ftype == TType.STOP:
20952 
        break
20953 
      if fid == 1:
20954 
        if ftype == TType.I64:
20955 
          self.orderId = iprot.readI64();
20956 
        else:
20957 
          iprot.skip(ftype)
20958 
      elif fid == 2:
20959 
        if ftype == TType.I64:
20960 
          self.warehouseId = iprot.readI64();
20961 
        else:
20962 
          iprot.skip(ftype)
20963 
      else:
20964 
        iprot.skip(ftype)
20965 
      iprot.readFieldEnd()
20966 
    iprot.readStructEnd()
20967 
 
20968 
  def write(self, oprot):
20969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20971 
      return
20972 
    oprot.writeStructBegin('shiftToWarehouse_args')
20973 
    if self.orderId is not None:
20974 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20975 
      oprot.writeI64(self.orderId)
20976 
      oprot.writeFieldEnd()
20977 
    if self.warehouseId is not None:
20978 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20979 
      oprot.writeI64(self.warehouseId)
20980 
      oprot.writeFieldEnd()
20981 
    oprot.writeFieldStop()
20982 
    oprot.writeStructEnd()
20983 
 
20984 
  def validate(self):
20985 
    return
20986 
 
20987 
 
20988 
  def __repr__(self):
20989 
    L = ['%s=%r' % (key, value)
20990 
      for key, value in self.__dict__.iteritems()]
20991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20992 
 
20993 
  def __eq__(self, other):
20994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20995 
 
20996 
  def __ne__(self, other):
20997 
    return not (self == other)
20998 
 
20999 
class shiftToWarehouse_result:
21000 
  """
21001 
  Attributes:
21002 
   - success
21003 
   - ex
21004 
  """
21005 
 
21006 
  thrift_spec = (
21007 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21008 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21009 
  )
21010 
 
21011 
  def __init__(self, success=None, ex=None,):
21012 
    self.success = success
21013 
    self.ex = ex
21014 
 
21015 
  def read(self, iprot):
21016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21018 
      return
21019 
    iprot.readStructBegin()
21020 
    while True:
21021 
      (fname, ftype, fid) = iprot.readFieldBegin()
21022 
      if ftype == TType.STOP:
21023 
        break
21024 
      if fid == 0:
21025 
        if ftype == TType.STRUCT:
21026 
          self.success = Order()
21027 
          self.success.read(iprot)
21028 
        else:
21029 
          iprot.skip(ftype)
21030 
      elif fid == 1:
21031 
        if ftype == TType.STRUCT:
21032 
          self.ex = TransactionServiceException()
21033 
          self.ex.read(iprot)
21034 
        else:
21035 
          iprot.skip(ftype)
21036 
      else:
21037 
        iprot.skip(ftype)
21038 
      iprot.readFieldEnd()
21039 
    iprot.readStructEnd()
21040 
 
21041 
  def write(self, oprot):
21042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21044 
      return
21045 
    oprot.writeStructBegin('shiftToWarehouse_result')
21046 
    if self.success is not None:
21047 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21048 
      self.success.write(oprot)
21049 
      oprot.writeFieldEnd()
21050 
    if self.ex is not None:
21051 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21052 
      self.ex.write(oprot)
21053 
      oprot.writeFieldEnd()
21054 
    oprot.writeFieldStop()
21055 
    oprot.writeStructEnd()
21056 
 
21057 
  def validate(self):
21058 
    return
21059 
 
21060 
 
21061 
  def __repr__(self):
21062 
    L = ['%s=%r' % (key, value)
21063 
      for key, value in self.__dict__.iteritems()]
21064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21065 
 
21066 
  def __eq__(self, other):
21067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21068 
 
21069 
  def __ne__(self, other):
21070 
    return not (self == other)
3553 chandransh 21071 
 
21072 
class addDelayReason_args:
21073 
  """
21074 
  Attributes:
21075 
   - orderId
21076 
   - delayReason
3986 chandransh 21077 
   - furtherDelay
4647 rajveer 21078 
   - delayReasonText
3553 chandransh 21079 
  """
21080 
 
21081 
  thrift_spec = (
21082 
    None, # 0
21083 
    (1, TType.I64, 'orderId', None, None, ), # 1
21084 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 21085 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 21086 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 21087 
  )
21088 
 
4647 rajveer 21089 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 21090 
    self.orderId = orderId
21091 
    self.delayReason = delayReason
3986 chandransh 21092 
    self.furtherDelay = furtherDelay
4647 rajveer 21093 
    self.delayReasonText = delayReasonText
3553 chandransh 21094 
 
21095 
  def read(self, iprot):
21096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21098 
      return
21099 
    iprot.readStructBegin()
21100 
    while True:
21101 
      (fname, ftype, fid) = iprot.readFieldBegin()
21102 
      if ftype == TType.STOP:
21103 
        break
21104 
      if fid == 1:
21105 
        if ftype == TType.I64:
21106 
          self.orderId = iprot.readI64();
21107 
        else:
21108 
          iprot.skip(ftype)
21109 
      elif fid == 2:
21110 
        if ftype == TType.I32:
21111 
          self.delayReason = iprot.readI32();
21112 
        else:
21113 
          iprot.skip(ftype)
3986 chandransh 21114 
      elif fid == 3:
21115 
        if ftype == TType.I64:
21116 
          self.furtherDelay = iprot.readI64();
21117 
        else:
21118 
          iprot.skip(ftype)
4647 rajveer 21119 
      elif fid == 4:
21120 
        if ftype == TType.STRING:
21121 
          self.delayReasonText = iprot.readString();
21122 
        else:
21123 
          iprot.skip(ftype)
3553 chandransh 21124 
      else:
21125 
        iprot.skip(ftype)
21126 
      iprot.readFieldEnd()
21127 
    iprot.readStructEnd()
21128 
 
21129 
  def write(self, oprot):
21130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21132 
      return
21133 
    oprot.writeStructBegin('addDelayReason_args')
21134 
    if self.orderId is not None:
21135 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21136 
      oprot.writeI64(self.orderId)
21137 
      oprot.writeFieldEnd()
21138 
    if self.delayReason is not None:
21139 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
21140 
      oprot.writeI32(self.delayReason)
21141 
      oprot.writeFieldEnd()
3986 chandransh 21142 
    if self.furtherDelay is not None:
21143 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
21144 
      oprot.writeI64(self.furtherDelay)
21145 
      oprot.writeFieldEnd()
4647 rajveer 21146 
    if self.delayReasonText is not None:
21147 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
21148 
      oprot.writeString(self.delayReasonText)
21149 
      oprot.writeFieldEnd()
3553 chandransh 21150 
    oprot.writeFieldStop()
21151 
    oprot.writeStructEnd()
21152 
 
21153 
  def validate(self):
21154 
    return
21155 
 
21156 
 
21157 
  def __repr__(self):
21158 
    L = ['%s=%r' % (key, value)
21159 
      for key, value in self.__dict__.iteritems()]
21160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21161 
 
21162 
  def __eq__(self, other):
21163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21164 
 
21165 
  def __ne__(self, other):
21166 
    return not (self == other)
21167 
 
21168 
class addDelayReason_result:
21169 
  """
21170 
  Attributes:
21171 
   - success
21172 
   - ex
21173 
  """
21174 
 
21175 
  thrift_spec = (
21176 
    (0, TType.BOOL, 'success', None, None, ), # 0
21177 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21178 
  )
21179 
 
21180 
  def __init__(self, success=None, ex=None,):
21181 
    self.success = success
21182 
    self.ex = ex
21183 
 
21184 
  def read(self, iprot):
21185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21187 
      return
21188 
    iprot.readStructBegin()
21189 
    while True:
21190 
      (fname, ftype, fid) = iprot.readFieldBegin()
21191 
      if ftype == TType.STOP:
21192 
        break
21193 
      if fid == 0:
21194 
        if ftype == TType.BOOL:
21195 
          self.success = iprot.readBool();
21196 
        else:
21197 
          iprot.skip(ftype)
21198 
      elif fid == 1:
21199 
        if ftype == TType.STRUCT:
21200 
          self.ex = TransactionServiceException()
21201 
          self.ex.read(iprot)
21202 
        else:
21203 
          iprot.skip(ftype)
21204 
      else:
21205 
        iprot.skip(ftype)
21206 
      iprot.readFieldEnd()
21207 
    iprot.readStructEnd()
21208 
 
21209 
  def write(self, oprot):
21210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21212 
      return
21213 
    oprot.writeStructBegin('addDelayReason_result')
21214 
    if self.success is not None:
21215 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21216 
      oprot.writeBool(self.success)
21217 
      oprot.writeFieldEnd()
21218 
    if self.ex is not None:
21219 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21220 
      self.ex.write(oprot)
21221 
      oprot.writeFieldEnd()
21222 
    oprot.writeFieldStop()
21223 
    oprot.writeStructEnd()
21224 
 
21225 
  def validate(self):
21226 
    return
21227 
 
21228 
 
21229 
  def __repr__(self):
21230 
    L = ['%s=%r' % (key, value)
21231 
      for key, value in self.__dict__.iteritems()]
21232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21233 
 
21234 
  def __eq__(self, other):
21235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21236 
 
21237 
  def __ne__(self, other):
21238 
    return not (self == other)
3956 chandransh 21239 
 
21240 
class reconcileCodCollection_args:
21241 
  """
21242 
  Attributes:
21243 
   - collectedAmountMap
21244 
   - xferBy
21245 
   - xferTxnId
21246 
   - xferDate
21247 
  """
21248 
 
21249 
  thrift_spec = (
21250 
    None, # 0
21251 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
21252 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
21253 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
21254 
    (4, TType.I64, 'xferDate', None, None, ), # 4
21255 
  )
21256 
 
21257 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
21258 
    self.collectedAmountMap = collectedAmountMap
21259 
    self.xferBy = xferBy
21260 
    self.xferTxnId = xferTxnId
21261 
    self.xferDate = xferDate
21262 
 
21263 
  def read(self, iprot):
21264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21266 
      return
21267 
    iprot.readStructBegin()
21268 
    while True:
21269 
      (fname, ftype, fid) = iprot.readFieldBegin()
21270 
      if ftype == TType.STOP:
21271 
        break
21272 
      if fid == 1:
21273 
        if ftype == TType.MAP:
21274 
          self.collectedAmountMap = {}
6188 rajveer 21275 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
21276 
          for _i457 in xrange(_size453):
21277 
            _key458 = iprot.readString();
21278 
            _val459 = iprot.readDouble();
21279 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 21280 
          iprot.readMapEnd()
21281 
        else:
21282 
          iprot.skip(ftype)
21283 
      elif fid == 2:
21284 
        if ftype == TType.STRING:
21285 
          self.xferBy = iprot.readString();
21286 
        else:
21287 
          iprot.skip(ftype)
21288 
      elif fid == 3:
21289 
        if ftype == TType.STRING:
21290 
          self.xferTxnId = iprot.readString();
21291 
        else:
21292 
          iprot.skip(ftype)
21293 
      elif fid == 4:
21294 
        if ftype == TType.I64:
21295 
          self.xferDate = iprot.readI64();
21296 
        else:
21297 
          iprot.skip(ftype)
21298 
      else:
21299 
        iprot.skip(ftype)
21300 
      iprot.readFieldEnd()
21301 
    iprot.readStructEnd()
21302 
 
21303 
  def write(self, oprot):
21304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21306 
      return
21307 
    oprot.writeStructBegin('reconcileCodCollection_args')
21308 
    if self.collectedAmountMap is not None:
21309 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
21310 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 21311 
      for kiter460,viter461 in self.collectedAmountMap.items():
21312 
        oprot.writeString(kiter460)
21313 
        oprot.writeDouble(viter461)
3956 chandransh 21314 
      oprot.writeMapEnd()
21315 
      oprot.writeFieldEnd()
21316 
    if self.xferBy is not None:
21317 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
21318 
      oprot.writeString(self.xferBy)
21319 
      oprot.writeFieldEnd()
21320 
    if self.xferTxnId is not None:
21321 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
21322 
      oprot.writeString(self.xferTxnId)
21323 
      oprot.writeFieldEnd()
21324 
    if self.xferDate is not None:
21325 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
21326 
      oprot.writeI64(self.xferDate)
21327 
      oprot.writeFieldEnd()
21328 
    oprot.writeFieldStop()
21329 
    oprot.writeStructEnd()
21330 
 
21331 
  def validate(self):
21332 
    return
21333 
 
21334 
 
21335 
  def __repr__(self):
21336 
    L = ['%s=%r' % (key, value)
21337 
      for key, value in self.__dict__.iteritems()]
21338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21339 
 
21340 
  def __eq__(self, other):
21341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21342 
 
21343 
  def __ne__(self, other):
21344 
    return not (self == other)
21345 
 
21346 
class reconcileCodCollection_result:
21347 
  """
21348 
  Attributes:
21349 
   - success
21350 
   - ex
21351 
  """
21352 
 
21353 
  thrift_spec = (
21354 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
21355 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21356 
  )
21357 
 
21358 
  def __init__(self, success=None, ex=None,):
21359 
    self.success = success
21360 
    self.ex = ex
21361 
 
21362 
  def read(self, iprot):
21363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21365 
      return
21366 
    iprot.readStructBegin()
21367 
    while True:
21368 
      (fname, ftype, fid) = iprot.readFieldBegin()
21369 
      if ftype == TType.STOP:
21370 
        break
21371 
      if fid == 0:
21372 
        if ftype == TType.MAP:
21373 
          self.success = {}
6188 rajveer 21374 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
21375 
          for _i466 in xrange(_size462):
21376 
            _key467 = iprot.readString();
21377 
            _val468 = iprot.readString();
21378 
            self.success[_key467] = _val468
3956 chandransh 21379 
          iprot.readMapEnd()
21380 
        else:
21381 
          iprot.skip(ftype)
21382 
      elif fid == 1:
21383 
        if ftype == TType.STRUCT:
21384 
          self.ex = TransactionServiceException()
21385 
          self.ex.read(iprot)
21386 
        else:
21387 
          iprot.skip(ftype)
21388 
      else:
21389 
        iprot.skip(ftype)
21390 
      iprot.readFieldEnd()
21391 
    iprot.readStructEnd()
21392 
 
21393 
  def write(self, oprot):
21394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21396 
      return
21397 
    oprot.writeStructBegin('reconcileCodCollection_result')
21398 
    if self.success is not None:
21399 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21400 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 21401 
      for kiter469,viter470 in self.success.items():
21402 
        oprot.writeString(kiter469)
21403 
        oprot.writeString(viter470)
3956 chandransh 21404 
      oprot.writeMapEnd()
21405 
      oprot.writeFieldEnd()
21406 
    if self.ex is not None:
21407 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21408 
      self.ex.write(oprot)
21409 
      oprot.writeFieldEnd()
21410 
    oprot.writeFieldStop()
21411 
    oprot.writeStructEnd()
21412 
 
21413 
  def validate(self):
21414 
    return
21415 
 
21416 
 
21417 
  def __repr__(self):
21418 
    L = ['%s=%r' % (key, value)
21419 
      for key, value in self.__dict__.iteritems()]
21420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21421 
 
21422 
  def __eq__(self, other):
21423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21424 
 
21425 
  def __ne__(self, other):
21426 
    return not (self == other)
4008 mandeep.dh 21427 
 
21428 
class getTransactionsRequiringExtraProcessing_args:
21429 
  """
21430 
  Attributes:
21431 
   - category
21432 
  """
21433 
 
21434 
  thrift_spec = (
21435 
    None, # 0
21436 
    (1, TType.I32, 'category', None, None, ), # 1
21437 
  )
21438 
 
21439 
  def __init__(self, category=None,):
21440 
    self.category = category
21441 
 
21442 
  def read(self, iprot):
21443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21445 
      return
21446 
    iprot.readStructBegin()
21447 
    while True:
21448 
      (fname, ftype, fid) = iprot.readFieldBegin()
21449 
      if ftype == TType.STOP:
21450 
        break
21451 
      if fid == 1:
21452 
        if ftype == TType.I32:
21453 
          self.category = iprot.readI32();
21454 
        else:
21455 
          iprot.skip(ftype)
21456 
      else:
21457 
        iprot.skip(ftype)
21458 
      iprot.readFieldEnd()
21459 
    iprot.readStructEnd()
21460 
 
21461 
  def write(self, oprot):
21462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21464 
      return
21465 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
21466 
    if self.category is not None:
21467 
      oprot.writeFieldBegin('category', TType.I32, 1)
21468 
      oprot.writeI32(self.category)
21469 
      oprot.writeFieldEnd()
21470 
    oprot.writeFieldStop()
21471 
    oprot.writeStructEnd()
21472 
 
21473 
  def validate(self):
21474 
    return
21475 
 
21476 
 
21477 
  def __repr__(self):
21478 
    L = ['%s=%r' % (key, value)
21479 
      for key, value in self.__dict__.iteritems()]
21480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21481 
 
21482 
  def __eq__(self, other):
21483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21484 
 
21485 
  def __ne__(self, other):
21486 
    return not (self == other)
21487 
 
21488 
class getTransactionsRequiringExtraProcessing_result:
21489 
  """
21490 
  Attributes:
21491 
   - success
21492 
  """
21493 
 
21494 
  thrift_spec = (
21495 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21496 
  )
21497 
 
21498 
  def __init__(self, success=None,):
21499 
    self.success = success
21500 
 
21501 
  def read(self, iprot):
21502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21504 
      return
21505 
    iprot.readStructBegin()
21506 
    while True:
21507 
      (fname, ftype, fid) = iprot.readFieldBegin()
21508 
      if ftype == TType.STOP:
21509 
        break
21510 
      if fid == 0:
21511 
        if ftype == TType.LIST:
21512 
          self.success = []
6188 rajveer 21513 
          (_etype474, _size471) = iprot.readListBegin()
21514 
          for _i475 in xrange(_size471):
21515 
            _elem476 = iprot.readI64();
21516 
            self.success.append(_elem476)
4008 mandeep.dh 21517 
          iprot.readListEnd()
21518 
        else:
21519 
          iprot.skip(ftype)
21520 
      else:
21521 
        iprot.skip(ftype)
21522 
      iprot.readFieldEnd()
21523 
    iprot.readStructEnd()
21524 
 
21525 
  def write(self, oprot):
21526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21528 
      return
21529 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
21530 
    if self.success is not None:
21531 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21532 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 21533 
      for iter477 in self.success:
21534 
        oprot.writeI64(iter477)
4008 mandeep.dh 21535 
      oprot.writeListEnd()
21536 
      oprot.writeFieldEnd()
21537 
    oprot.writeFieldStop()
21538 
    oprot.writeStructEnd()
21539 
 
21540 
  def validate(self):
21541 
    return
21542 
 
21543 
 
21544 
  def __repr__(self):
21545 
    L = ['%s=%r' % (key, value)
21546 
      for key, value in self.__dict__.iteritems()]
21547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21548 
 
21549 
  def __eq__(self, other):
21550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21551 
 
21552 
  def __ne__(self, other):
21553 
    return not (self == other)
21554 
 
21555 
class markTransactionAsProcessed_args:
21556 
  """
21557 
  Attributes:
21558 
   - transactionId
21559 
   - category
21560 
  """
21561 
 
21562 
  thrift_spec = (
21563 
    None, # 0
21564 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21565 
    (2, TType.I32, 'category', None, None, ), # 2
21566 
  )
21567 
 
21568 
  def __init__(self, transactionId=None, category=None,):
21569 
    self.transactionId = transactionId
21570 
    self.category = category
21571 
 
21572 
  def read(self, iprot):
21573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21575 
      return
21576 
    iprot.readStructBegin()
21577 
    while True:
21578 
      (fname, ftype, fid) = iprot.readFieldBegin()
21579 
      if ftype == TType.STOP:
21580 
        break
21581 
      if fid == 1:
21582 
        if ftype == TType.I64:
21583 
          self.transactionId = iprot.readI64();
21584 
        else:
21585 
          iprot.skip(ftype)
21586 
      elif fid == 2:
21587 
        if ftype == TType.I32:
21588 
          self.category = iprot.readI32();
21589 
        else:
21590 
          iprot.skip(ftype)
21591 
      else:
21592 
        iprot.skip(ftype)
21593 
      iprot.readFieldEnd()
21594 
    iprot.readStructEnd()
21595 
 
21596 
  def write(self, oprot):
21597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21599 
      return
21600 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
21601 
    if self.transactionId is not None:
21602 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21603 
      oprot.writeI64(self.transactionId)
21604 
      oprot.writeFieldEnd()
21605 
    if self.category is not None:
21606 
      oprot.writeFieldBegin('category', TType.I32, 2)
21607 
      oprot.writeI32(self.category)
21608 
      oprot.writeFieldEnd()
21609 
    oprot.writeFieldStop()
21610 
    oprot.writeStructEnd()
21611 
 
21612 
  def validate(self):
21613 
    return
21614 
 
21615 
 
21616 
  def __repr__(self):
21617 
    L = ['%s=%r' % (key, value)
21618 
      for key, value in self.__dict__.iteritems()]
21619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21620 
 
21621 
  def __eq__(self, other):
21622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21623 
 
21624 
  def __ne__(self, other):
21625 
    return not (self == other)
21626 
 
21627 
class markTransactionAsProcessed_result:
21628 
 
21629 
  thrift_spec = (
21630 
  )
21631 
 
21632 
  def read(self, iprot):
21633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21635 
      return
21636 
    iprot.readStructBegin()
21637 
    while True:
21638 
      (fname, ftype, fid) = iprot.readFieldBegin()
21639 
      if ftype == TType.STOP:
21640 
        break
21641 
      else:
21642 
        iprot.skip(ftype)
21643 
      iprot.readFieldEnd()
21644 
    iprot.readStructEnd()
21645 
 
21646 
  def write(self, oprot):
21647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21649 
      return
21650 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
21651 
    oprot.writeFieldStop()
21652 
    oprot.writeStructEnd()
21653 
 
21654 
  def validate(self):
21655 
    return
21656 
 
21657 
 
21658 
  def __repr__(self):
21659 
    L = ['%s=%r' % (key, value)
21660 
      for key, value in self.__dict__.iteritems()]
21661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21662 
 
21663 
  def __eq__(self, other):
21664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21665 
 
21666 
  def __ne__(self, other):
21667 
    return not (self == other)
4018 chandransh 21668 
 
21669 
class getItemWiseRiskyOrdersCount_args:
21670 
 
21671 
  thrift_spec = (
21672 
  )
21673 
 
21674 
  def read(self, iprot):
21675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21677 
      return
21678 
    iprot.readStructBegin()
21679 
    while True:
21680 
      (fname, ftype, fid) = iprot.readFieldBegin()
21681 
      if ftype == TType.STOP:
21682 
        break
21683 
      else:
21684 
        iprot.skip(ftype)
21685 
      iprot.readFieldEnd()
21686 
    iprot.readStructEnd()
21687 
 
21688 
  def write(self, oprot):
21689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21691 
      return
21692 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
21693 
    oprot.writeFieldStop()
21694 
    oprot.writeStructEnd()
21695 
 
21696 
  def validate(self):
21697 
    return
21698 
 
21699 
 
21700 
  def __repr__(self):
21701 
    L = ['%s=%r' % (key, value)
21702 
      for key, value in self.__dict__.iteritems()]
21703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21704 
 
21705 
  def __eq__(self, other):
21706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21707 
 
21708 
  def __ne__(self, other):
21709 
    return not (self == other)
21710 
 
21711 
class getItemWiseRiskyOrdersCount_result:
21712 
  """
21713 
  Attributes:
21714 
   - success
21715 
  """
21716 
 
21717 
  thrift_spec = (
21718 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21719 
  )
21720 
 
21721 
  def __init__(self, success=None,):
21722 
    self.success = success
21723 
 
21724 
  def read(self, iprot):
21725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21727 
      return
21728 
    iprot.readStructBegin()
21729 
    while True:
21730 
      (fname, ftype, fid) = iprot.readFieldBegin()
21731 
      if ftype == TType.STOP:
21732 
        break
21733 
      if fid == 0:
21734 
        if ftype == TType.MAP:
21735 
          self.success = {}
6188 rajveer 21736 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
21737 
          for _i482 in xrange(_size478):
21738 
            _key483 = iprot.readI64();
21739 
            _val484 = iprot.readI64();
21740 
            self.success[_key483] = _val484
4018 chandransh 21741 
          iprot.readMapEnd()
21742 
        else:
21743 
          iprot.skip(ftype)
21744 
      else:
21745 
        iprot.skip(ftype)
21746 
      iprot.readFieldEnd()
21747 
    iprot.readStructEnd()
21748 
 
21749 
  def write(self, oprot):
21750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21752 
      return
21753 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
21754 
    if self.success is not None:
21755 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21756 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 21757 
      for kiter485,viter486 in self.success.items():
21758 
        oprot.writeI64(kiter485)
21759 
        oprot.writeI64(viter486)
4018 chandransh 21760 
      oprot.writeMapEnd()
21761 
      oprot.writeFieldEnd()
21762 
    oprot.writeFieldStop()
21763 
    oprot.writeStructEnd()
21764 
 
21765 
  def validate(self):
21766 
    return
21767 
 
21768 
 
21769 
  def __repr__(self):
21770 
    L = ['%s=%r' % (key, value)
21771 
      for key, value in self.__dict__.iteritems()]
21772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21773 
 
21774 
  def __eq__(self, other):
21775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21776 
 
21777 
  def __ne__(self, other):
21778 
    return not (self == other)
4247 rajveer 21779 
 
4295 varun.gupt 21780 
class getOrdersForItemIds_args:
21781 
  """
21782 
  Attributes:
21783 
   - itemIds
21784 
  """
21785 
 
21786 
  thrift_spec = (
21787 
    None, # 0
21788 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21789 
  )
21790 
 
21791 
  def __init__(self, itemIds=None,):
21792 
    self.itemIds = itemIds
21793 
 
21794 
  def read(self, iprot):
21795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21797 
      return
21798 
    iprot.readStructBegin()
21799 
    while True:
21800 
      (fname, ftype, fid) = iprot.readFieldBegin()
21801 
      if ftype == TType.STOP:
21802 
        break
21803 
      if fid == 1:
21804 
        if ftype == TType.LIST:
21805 
          self.itemIds = []
6188 rajveer 21806 
          (_etype490, _size487) = iprot.readListBegin()
21807 
          for _i491 in xrange(_size487):
21808 
            _elem492 = iprot.readI64();
21809 
            self.itemIds.append(_elem492)
4295 varun.gupt 21810 
          iprot.readListEnd()
21811 
        else:
21812 
          iprot.skip(ftype)
21813 
      else:
21814 
        iprot.skip(ftype)
21815 
      iprot.readFieldEnd()
21816 
    iprot.readStructEnd()
21817 
 
21818 
  def write(self, oprot):
21819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21821 
      return
21822 
    oprot.writeStructBegin('getOrdersForItemIds_args')
21823 
    if self.itemIds is not None:
21824 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21825 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21826 
      for iter493 in self.itemIds:
21827 
        oprot.writeI64(iter493)
4295 varun.gupt 21828 
      oprot.writeListEnd()
21829 
      oprot.writeFieldEnd()
21830 
    oprot.writeFieldStop()
21831 
    oprot.writeStructEnd()
21832 
 
21833 
  def validate(self):
21834 
    return
21835 
 
21836 
 
21837 
  def __repr__(self):
21838 
    L = ['%s=%r' % (key, value)
21839 
      for key, value in self.__dict__.iteritems()]
21840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21841 
 
21842 
  def __eq__(self, other):
21843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21844 
 
21845 
  def __ne__(self, other):
21846 
    return not (self == other)
21847 
 
21848 
class getOrdersForItemIds_result:
21849 
  """
21850 
  Attributes:
21851 
   - success
21852 
  """
21853 
 
21854 
  thrift_spec = (
21855 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21856 
  )
21857 
 
21858 
  def __init__(self, success=None,):
21859 
    self.success = success
21860 
 
21861 
  def read(self, iprot):
21862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21864 
      return
21865 
    iprot.readStructBegin()
21866 
    while True:
21867 
      (fname, ftype, fid) = iprot.readFieldBegin()
21868 
      if ftype == TType.STOP:
21869 
        break
21870 
      if fid == 0:
21871 
        if ftype == TType.LIST:
21872 
          self.success = []
6188 rajveer 21873 
          (_etype497, _size494) = iprot.readListBegin()
21874 
          for _i498 in xrange(_size494):
21875 
            _elem499 = Order()
21876 
            _elem499.read(iprot)
21877 
            self.success.append(_elem499)
4295 varun.gupt 21878 
          iprot.readListEnd()
21879 
        else:
21880 
          iprot.skip(ftype)
21881 
      else:
21882 
        iprot.skip(ftype)
21883 
      iprot.readFieldEnd()
21884 
    iprot.readStructEnd()
21885 
 
21886 
  def write(self, oprot):
21887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21889 
      return
21890 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21891 
    if self.success is not None:
21892 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21893 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21894 
      for iter500 in self.success:
21895 
        iter500.write(oprot)
4295 varun.gupt 21896 
      oprot.writeListEnd()
21897 
      oprot.writeFieldEnd()
21898 
    oprot.writeFieldStop()
21899 
    oprot.writeStructEnd()
21900 
 
21901 
  def validate(self):
21902 
    return
21903 
 
21904 
 
21905 
  def __repr__(self):
21906 
    L = ['%s=%r' % (key, value)
21907 
      for key, value in self.__dict__.iteritems()]
21908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21909 
 
21910 
  def __eq__(self, other):
21911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21912 
 
21913 
  def __ne__(self, other):
21914 
    return not (self == other)
21915 
 
4247 rajveer 21916 
class markOrderCancellationRequestReceived_args:
21917 
  """
21918 
  Attributes:
21919 
   - orderId
21920 
  """
21921 
 
21922 
  thrift_spec = (
21923 
    None, # 0
21924 
    (1, TType.I64, 'orderId', None, None, ), # 1
21925 
  )
21926 
 
21927 
  def __init__(self, orderId=None,):
21928 
    self.orderId = orderId
21929 
 
21930 
  def read(self, iprot):
21931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21933 
      return
21934 
    iprot.readStructBegin()
21935 
    while True:
21936 
      (fname, ftype, fid) = iprot.readFieldBegin()
21937 
      if ftype == TType.STOP:
21938 
        break
21939 
      if fid == 1:
21940 
        if ftype == TType.I64:
21941 
          self.orderId = iprot.readI64();
21942 
        else:
21943 
          iprot.skip(ftype)
21944 
      else:
21945 
        iprot.skip(ftype)
21946 
      iprot.readFieldEnd()
21947 
    iprot.readStructEnd()
21948 
 
21949 
  def write(self, oprot):
21950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21952 
      return
21953 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21954 
    if self.orderId is not None:
21955 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21956 
      oprot.writeI64(self.orderId)
21957 
      oprot.writeFieldEnd()
21958 
    oprot.writeFieldStop()
21959 
    oprot.writeStructEnd()
21960 
 
21961 
  def validate(self):
21962 
    return
21963 
 
21964 
 
21965 
  def __repr__(self):
21966 
    L = ['%s=%r' % (key, value)
21967 
      for key, value in self.__dict__.iteritems()]
21968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21969 
 
21970 
  def __eq__(self, other):
21971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21972 
 
21973 
  def __ne__(self, other):
21974 
    return not (self == other)
21975 
 
21976 
class markOrderCancellationRequestReceived_result:
21977 
  """
21978 
  Attributes:
21979 
   - ex
21980 
  """
21981 
 
21982 
  thrift_spec = (
21983 
    None, # 0
21984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21985 
  )
21986 
 
21987 
  def __init__(self, ex=None,):
21988 
    self.ex = ex
21989 
 
21990 
  def read(self, iprot):
21991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21993 
      return
21994 
    iprot.readStructBegin()
21995 
    while True:
21996 
      (fname, ftype, fid) = iprot.readFieldBegin()
21997 
      if ftype == TType.STOP:
21998 
        break
21999 
      if fid == 1:
22000 
        if ftype == TType.STRUCT:
22001 
          self.ex = TransactionServiceException()
22002 
          self.ex.read(iprot)
22003 
        else:
22004 
          iprot.skip(ftype)
22005 
      else:
22006 
        iprot.skip(ftype)
22007 
      iprot.readFieldEnd()
22008 
    iprot.readStructEnd()
22009 
 
22010 
  def write(self, oprot):
22011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22013 
      return
22014 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
22015 
    if self.ex is not None:
22016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22017 
      self.ex.write(oprot)
22018 
      oprot.writeFieldEnd()
22019 
    oprot.writeFieldStop()
22020 
    oprot.writeStructEnd()
22021 
 
22022 
  def validate(self):
22023 
    return
22024 
 
22025 
 
22026 
  def __repr__(self):
22027 
    L = ['%s=%r' % (key, value)
22028 
      for key, value in self.__dict__.iteritems()]
22029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22030 
 
22031 
  def __eq__(self, other):
22032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22033 
 
22034 
  def __ne__(self, other):
22035 
    return not (self == other)
22036 
 
22037 
class markOrderCancellationRequestConfirmed_args:
22038 
  """
22039 
  Attributes:
22040 
   - orderId
22041 
  """
22042 
 
22043 
  thrift_spec = (
22044 
    None, # 0
22045 
    (1, TType.I64, 'orderId', None, None, ), # 1
22046 
  )
22047 
 
22048 
  def __init__(self, orderId=None,):
22049 
    self.orderId = orderId
22050 
 
22051 
  def read(self, iprot):
22052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22054 
      return
22055 
    iprot.readStructBegin()
22056 
    while True:
22057 
      (fname, ftype, fid) = iprot.readFieldBegin()
22058 
      if ftype == TType.STOP:
22059 
        break
22060 
      if fid == 1:
22061 
        if ftype == TType.I64:
22062 
          self.orderId = iprot.readI64();
22063 
        else:
22064 
          iprot.skip(ftype)
22065 
      else:
22066 
        iprot.skip(ftype)
22067 
      iprot.readFieldEnd()
22068 
    iprot.readStructEnd()
22069 
 
22070 
  def write(self, oprot):
22071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22073 
      return
22074 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
22075 
    if self.orderId is not None:
22076 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22077 
      oprot.writeI64(self.orderId)
22078 
      oprot.writeFieldEnd()
22079 
    oprot.writeFieldStop()
22080 
    oprot.writeStructEnd()
22081 
 
22082 
  def validate(self):
22083 
    return
22084 
 
22085 
 
22086 
  def __repr__(self):
22087 
    L = ['%s=%r' % (key, value)
22088 
      for key, value in self.__dict__.iteritems()]
22089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22090 
 
22091 
  def __eq__(self, other):
22092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22093 
 
22094 
  def __ne__(self, other):
22095 
    return not (self == other)
22096 
 
22097 
class markOrderCancellationRequestConfirmed_result:
22098 
  """
22099 
  Attributes:
22100 
   - ex
22101 
  """
22102 
 
22103 
  thrift_spec = (
22104 
    None, # 0
22105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22106 
  )
22107 
 
22108 
  def __init__(self, ex=None,):
22109 
    self.ex = ex
22110 
 
22111 
  def read(self, iprot):
22112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22114 
      return
22115 
    iprot.readStructBegin()
22116 
    while True:
22117 
      (fname, ftype, fid) = iprot.readFieldBegin()
22118 
      if ftype == TType.STOP:
22119 
        break
22120 
      if fid == 1:
22121 
        if ftype == TType.STRUCT:
22122 
          self.ex = TransactionServiceException()
22123 
          self.ex.read(iprot)
22124 
        else:
22125 
          iprot.skip(ftype)
22126 
      else:
22127 
        iprot.skip(ftype)
22128 
      iprot.readFieldEnd()
22129 
    iprot.readStructEnd()
22130 
 
22131 
  def write(self, oprot):
22132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22134 
      return
22135 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
22136 
    if self.ex is not None:
22137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22138 
      self.ex.write(oprot)
22139 
      oprot.writeFieldEnd()
22140 
    oprot.writeFieldStop()
22141 
    oprot.writeStructEnd()
22142 
 
22143 
  def validate(self):
22144 
    return
22145 
 
22146 
 
22147 
  def __repr__(self):
22148 
    L = ['%s=%r' % (key, value)
22149 
      for key, value in self.__dict__.iteritems()]
22150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22151 
 
22152 
  def __eq__(self, other):
22153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22154 
 
22155 
  def __ne__(self, other):
22156 
    return not (self == other)
22157 
 
22158 
class markOrderCancellationRequestDenied_args:
22159 
  """
22160 
  Attributes:
22161 
   - orderId
22162 
  """
22163 
 
22164 
  thrift_spec = (
22165 
    None, # 0
22166 
    (1, TType.I64, 'orderId', None, None, ), # 1
22167 
  )
22168 
 
22169 
  def __init__(self, orderId=None,):
22170 
    self.orderId = orderId
22171 
 
22172 
  def read(self, iprot):
22173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22175 
      return
22176 
    iprot.readStructBegin()
22177 
    while True:
22178 
      (fname, ftype, fid) = iprot.readFieldBegin()
22179 
      if ftype == TType.STOP:
22180 
        break
22181 
      if fid == 1:
22182 
        if ftype == TType.I64:
22183 
          self.orderId = iprot.readI64();
22184 
        else:
22185 
          iprot.skip(ftype)
22186 
      else:
22187 
        iprot.skip(ftype)
22188 
      iprot.readFieldEnd()
22189 
    iprot.readStructEnd()
22190 
 
22191 
  def write(self, oprot):
22192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22194 
      return
22195 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
22196 
    if self.orderId is not None:
22197 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22198 
      oprot.writeI64(self.orderId)
22199 
      oprot.writeFieldEnd()
22200 
    oprot.writeFieldStop()
22201 
    oprot.writeStructEnd()
22202 
 
22203 
  def validate(self):
22204 
    return
22205 
 
22206 
 
22207 
  def __repr__(self):
22208 
    L = ['%s=%r' % (key, value)
22209 
      for key, value in self.__dict__.iteritems()]
22210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22211 
 
22212 
  def __eq__(self, other):
22213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22214 
 
22215 
  def __ne__(self, other):
22216 
    return not (self == other)
22217 
 
22218 
class markOrderCancellationRequestDenied_result:
22219 
  """
22220 
  Attributes:
22221 
   - ex
22222 
  """
22223 
 
22224 
  thrift_spec = (
22225 
    None, # 0
22226 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22227 
  )
22228 
 
22229 
  def __init__(self, ex=None,):
22230 
    self.ex = ex
22231 
 
22232 
  def read(self, iprot):
22233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22235 
      return
22236 
    iprot.readStructBegin()
22237 
    while True:
22238 
      (fname, ftype, fid) = iprot.readFieldBegin()
22239 
      if ftype == TType.STOP:
22240 
        break
22241 
      if fid == 1:
22242 
        if ftype == TType.STRUCT:
22243 
          self.ex = TransactionServiceException()
22244 
          self.ex.read(iprot)
22245 
        else:
22246 
          iprot.skip(ftype)
22247 
      else:
22248 
        iprot.skip(ftype)
22249 
      iprot.readFieldEnd()
22250 
    iprot.readStructEnd()
22251 
 
22252 
  def write(self, oprot):
22253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22255 
      return
22256 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
22257 
    if self.ex is not None:
22258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22259 
      self.ex.write(oprot)
22260 
      oprot.writeFieldEnd()
22261 
    oprot.writeFieldStop()
22262 
    oprot.writeStructEnd()
22263 
 
22264 
  def validate(self):
22265 
    return
22266 
 
22267 
 
22268 
  def __repr__(self):
22269 
    L = ['%s=%r' % (key, value)
22270 
      for key, value in self.__dict__.iteritems()]
22271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22272 
 
22273 
  def __eq__(self, other):
22274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22275 
 
22276 
  def __ne__(self, other):
22277 
    return not (self == other)
22278 
 
4258 rajveer 22279 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 22280 
  """
22281 
  Attributes:
4258 rajveer 22282 
   - transactionId
4247 rajveer 22283 
  """
22284 
 
22285 
  thrift_spec = (
22286 
    None, # 0
4258 rajveer 22287 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 22288 
  )
22289 
 
4258 rajveer 22290 
  def __init__(self, transactionId=None,):
22291 
    self.transactionId = transactionId
4247 rajveer 22292 
 
22293 
  def read(self, iprot):
22294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22296 
      return
22297 
    iprot.readStructBegin()
22298 
    while True:
22299 
      (fname, ftype, fid) = iprot.readFieldBegin()
22300 
      if ftype == TType.STOP:
22301 
        break
22302 
      if fid == 1:
22303 
        if ftype == TType.I64:
4258 rajveer 22304 
          self.transactionId = iprot.readI64();
4247 rajveer 22305 
        else:
22306 
          iprot.skip(ftype)
22307 
      else:
22308 
        iprot.skip(ftype)
22309 
      iprot.readFieldEnd()
22310 
    iprot.readStructEnd()
22311 
 
22312 
  def write(self, oprot):
22313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22315 
      return
4258 rajveer 22316 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
22317 
    if self.transactionId is not None:
22318 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
22319 
      oprot.writeI64(self.transactionId)
4247 rajveer 22320 
      oprot.writeFieldEnd()
22321 
    oprot.writeFieldStop()
22322 
    oprot.writeStructEnd()
22323 
 
22324 
  def validate(self):
22325 
    return
22326 
 
22327 
 
22328 
  def __repr__(self):
22329 
    L = ['%s=%r' % (key, value)
22330 
      for key, value in self.__dict__.iteritems()]
22331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22332 
 
22333 
  def __eq__(self, other):
22334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22335 
 
22336 
  def __ne__(self, other):
22337 
    return not (self == other)
22338 
 
4258 rajveer 22339 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 22340 
  """
22341 
  Attributes:
22342 
   - ex
22343 
  """
22344 
 
22345 
  thrift_spec = (
22346 
    None, # 0
22347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22348 
  )
22349 
 
22350 
  def __init__(self, ex=None,):
22351 
    self.ex = ex
22352 
 
22353 
  def read(self, iprot):
22354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22356 
      return
22357 
    iprot.readStructBegin()
22358 
    while True:
22359 
      (fname, ftype, fid) = iprot.readFieldBegin()
22360 
      if ftype == TType.STOP:
22361 
        break
22362 
      if fid == 1:
22363 
        if ftype == TType.STRUCT:
22364 
          self.ex = TransactionServiceException()
22365 
          self.ex.read(iprot)
22366 
        else:
22367 
          iprot.skip(ftype)
22368 
      else:
22369 
        iprot.skip(ftype)
22370 
      iprot.readFieldEnd()
22371 
    iprot.readStructEnd()
22372 
 
22373 
  def write(self, oprot):
22374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22376 
      return
4258 rajveer 22377 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 22378 
    if self.ex is not None:
22379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22380 
      self.ex.write(oprot)
22381 
      oprot.writeFieldEnd()
22382 
    oprot.writeFieldStop()
22383 
    oprot.writeStructEnd()
22384 
 
22385 
  def validate(self):
22386 
    return
22387 
 
22388 
 
22389 
  def __repr__(self):
22390 
    L = ['%s=%r' % (key, value)
22391 
      for key, value in self.__dict__.iteritems()]
22392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22393 
 
22394 
  def __eq__(self, other):
22395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22396 
 
22397 
  def __ne__(self, other):
22398 
    return not (self == other)
4259 anupam.sin 22399 
 
22400 
class refundTransaction_args:
22401 
  """
22402 
  Attributes:
22403 
   - transactionId
22404 
   - refundedBy
22405 
   - reason
22406 
  """
22407 
 
22408 
  thrift_spec = (
22409 
    None, # 0
22410 
    (1, TType.I64, 'transactionId', None, None, ), # 1
22411 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
22412 
    (3, TType.STRING, 'reason', None, None, ), # 3
22413 
  )
22414 
 
22415 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
22416 
    self.transactionId = transactionId
22417 
    self.refundedBy = refundedBy
22418 
    self.reason = reason
22419 
 
22420 
  def read(self, iprot):
22421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22423 
      return
22424 
    iprot.readStructBegin()
22425 
    while True:
22426 
      (fname, ftype, fid) = iprot.readFieldBegin()
22427 
      if ftype == TType.STOP:
22428 
        break
22429 
      if fid == 1:
22430 
        if ftype == TType.I64:
22431 
          self.transactionId = iprot.readI64();
22432 
        else:
22433 
          iprot.skip(ftype)
22434 
      elif fid == 2:
22435 
        if ftype == TType.STRING:
22436 
          self.refundedBy = iprot.readString();
22437 
        else:
22438 
          iprot.skip(ftype)
22439 
      elif fid == 3:
22440 
        if ftype == TType.STRING:
22441 
          self.reason = iprot.readString();
22442 
        else:
22443 
          iprot.skip(ftype)
22444 
      else:
22445 
        iprot.skip(ftype)
22446 
      iprot.readFieldEnd()
22447 
    iprot.readStructEnd()
22448 
 
22449 
  def write(self, oprot):
22450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22452 
      return
22453 
    oprot.writeStructBegin('refundTransaction_args')
22454 
    if self.transactionId is not None:
22455 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
22456 
      oprot.writeI64(self.transactionId)
22457 
      oprot.writeFieldEnd()
22458 
    if self.refundedBy is not None:
22459 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
22460 
      oprot.writeString(self.refundedBy)
22461 
      oprot.writeFieldEnd()
22462 
    if self.reason is not None:
22463 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
22464 
      oprot.writeString(self.reason)
22465 
      oprot.writeFieldEnd()
22466 
    oprot.writeFieldStop()
22467 
    oprot.writeStructEnd()
22468 
 
22469 
  def validate(self):
22470 
    return
22471 
 
22472 
 
22473 
  def __repr__(self):
22474 
    L = ['%s=%r' % (key, value)
22475 
      for key, value in self.__dict__.iteritems()]
22476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22477 
 
22478 
  def __eq__(self, other):
22479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22480 
 
22481 
  def __ne__(self, other):
22482 
    return not (self == other)
22483 
 
22484 
class refundTransaction_result:
22485 
  """
22486 
  Attributes:
22487 
   - ex
22488 
  """
22489 
 
22490 
  thrift_spec = (
22491 
    None, # 0
22492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22493 
  )
22494 
 
22495 
  def __init__(self, ex=None,):
22496 
    self.ex = ex
22497 
 
22498 
  def read(self, iprot):
22499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22501 
      return
22502 
    iprot.readStructBegin()
22503 
    while True:
22504 
      (fname, ftype, fid) = iprot.readFieldBegin()
22505 
      if ftype == TType.STOP:
22506 
        break
22507 
      if fid == 1:
22508 
        if ftype == TType.STRUCT:
22509 
          self.ex = TransactionServiceException()
22510 
          self.ex.read(iprot)
22511 
        else:
22512 
          iprot.skip(ftype)
22513 
      else:
22514 
        iprot.skip(ftype)
22515 
      iprot.readFieldEnd()
22516 
    iprot.readStructEnd()
22517 
 
22518 
  def write(self, oprot):
22519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22521 
      return
22522 
    oprot.writeStructBegin('refundTransaction_result')
22523 
    if self.ex is not None:
22524 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22525 
      self.ex.write(oprot)
22526 
      oprot.writeFieldEnd()
22527 
    oprot.writeFieldStop()
22528 
    oprot.writeStructEnd()
22529 
 
22530 
  def validate(self):
22531 
    return
22532 
 
22533 
 
22534 
  def __repr__(self):
22535 
    L = ['%s=%r' % (key, value)
22536 
      for key, value in self.__dict__.iteritems()]
22537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22538 
 
22539 
  def __eq__(self, other):
22540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22541 
 
22542 
  def __ne__(self, other):
22543 
    return not (self == other)
4285 rajveer 22544 
 
4324 mandeep.dh 22545 
class updateShipmentAddress_args:
22546 
  """
22547 
  Attributes:
22548 
   - orderId
22549 
   - addressId
22550 
  """
22551 
 
22552 
  thrift_spec = (
22553 
    None, # 0
22554 
    (1, TType.I64, 'orderId', None, None, ), # 1
22555 
    (2, TType.I64, 'addressId', None, None, ), # 2
22556 
  )
22557 
 
22558 
  def __init__(self, orderId=None, addressId=None,):
22559 
    self.orderId = orderId
22560 
    self.addressId = addressId
22561 
 
22562 
  def read(self, iprot):
22563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22565 
      return
22566 
    iprot.readStructBegin()
22567 
    while True:
22568 
      (fname, ftype, fid) = iprot.readFieldBegin()
22569 
      if ftype == TType.STOP:
22570 
        break
22571 
      if fid == 1:
22572 
        if ftype == TType.I64:
22573 
          self.orderId = iprot.readI64();
22574 
        else:
22575 
          iprot.skip(ftype)
22576 
      elif fid == 2:
22577 
        if ftype == TType.I64:
22578 
          self.addressId = iprot.readI64();
22579 
        else:
22580 
          iprot.skip(ftype)
22581 
      else:
22582 
        iprot.skip(ftype)
22583 
      iprot.readFieldEnd()
22584 
    iprot.readStructEnd()
22585 
 
22586 
  def write(self, oprot):
22587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22589 
      return
22590 
    oprot.writeStructBegin('updateShipmentAddress_args')
22591 
    if self.orderId is not None:
22592 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22593 
      oprot.writeI64(self.orderId)
22594 
      oprot.writeFieldEnd()
22595 
    if self.addressId is not None:
22596 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
22597 
      oprot.writeI64(self.addressId)
22598 
      oprot.writeFieldEnd()
22599 
    oprot.writeFieldStop()
22600 
    oprot.writeStructEnd()
22601 
 
22602 
  def validate(self):
22603 
    return
22604 
 
22605 
 
22606 
  def __repr__(self):
22607 
    L = ['%s=%r' % (key, value)
22608 
      for key, value in self.__dict__.iteritems()]
22609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22610 
 
22611 
  def __eq__(self, other):
22612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22613 
 
22614 
  def __ne__(self, other):
22615 
    return not (self == other)
22616 
 
22617 
class updateShipmentAddress_result:
22618 
  """
22619 
  Attributes:
22620 
   - ex
22621 
  """
22622 
 
22623 
  thrift_spec = (
22624 
    None, # 0
22625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22626 
  )
22627 
 
22628 
  def __init__(self, ex=None,):
22629 
    self.ex = ex
22630 
 
22631 
  def read(self, iprot):
22632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22634 
      return
22635 
    iprot.readStructBegin()
22636 
    while True:
22637 
      (fname, ftype, fid) = iprot.readFieldBegin()
22638 
      if ftype == TType.STOP:
22639 
        break
22640 
      if fid == 1:
22641 
        if ftype == TType.STRUCT:
22642 
          self.ex = TransactionServiceException()
22643 
          self.ex.read(iprot)
22644 
        else:
22645 
          iprot.skip(ftype)
22646 
      else:
22647 
        iprot.skip(ftype)
22648 
      iprot.readFieldEnd()
22649 
    iprot.readStructEnd()
22650 
 
22651 
  def write(self, oprot):
22652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22654 
      return
22655 
    oprot.writeStructBegin('updateShipmentAddress_result')
22656 
    if self.ex is not None:
22657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22658 
      self.ex.write(oprot)
22659 
      oprot.writeFieldEnd()
22660 
    oprot.writeFieldStop()
22661 
    oprot.writeStructEnd()
22662 
 
22663 
  def validate(self):
22664 
    return
22665 
 
22666 
 
22667 
  def __repr__(self):
22668 
    L = ['%s=%r' % (key, value)
22669 
      for key, value in self.__dict__.iteritems()]
22670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22671 
 
22672 
  def __eq__(self, other):
22673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22674 
 
22675 
  def __ne__(self, other):
22676 
    return not (self == other)
22677 
 
4285 rajveer 22678 
class acceptOrdersForItemId_args:
22679 
  """
22680 
  Attributes:
22681 
   - itemId
22682 
   - inventory
22683 
  """
22684 
 
22685 
  thrift_spec = (
22686 
    None, # 0
22687 
    (1, TType.I64, 'itemId', None, None, ), # 1
22688 
    (2, TType.I64, 'inventory', None, None, ), # 2
22689 
  )
22690 
 
22691 
  def __init__(self, itemId=None, inventory=None,):
22692 
    self.itemId = itemId
22693 
    self.inventory = inventory
22694 
 
22695 
  def read(self, iprot):
22696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22698 
      return
22699 
    iprot.readStructBegin()
22700 
    while True:
22701 
      (fname, ftype, fid) = iprot.readFieldBegin()
22702 
      if ftype == TType.STOP:
22703 
        break
22704 
      if fid == 1:
22705 
        if ftype == TType.I64:
22706 
          self.itemId = iprot.readI64();
22707 
        else:
22708 
          iprot.skip(ftype)
22709 
      elif fid == 2:
22710 
        if ftype == TType.I64:
22711 
          self.inventory = iprot.readI64();
22712 
        else:
22713 
          iprot.skip(ftype)
22714 
      else:
22715 
        iprot.skip(ftype)
22716 
      iprot.readFieldEnd()
22717 
    iprot.readStructEnd()
22718 
 
22719 
  def write(self, oprot):
22720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22722 
      return
22723 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
22724 
    if self.itemId is not None:
22725 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22726 
      oprot.writeI64(self.itemId)
22727 
      oprot.writeFieldEnd()
22728 
    if self.inventory is not None:
22729 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
22730 
      oprot.writeI64(self.inventory)
22731 
      oprot.writeFieldEnd()
22732 
    oprot.writeFieldStop()
22733 
    oprot.writeStructEnd()
22734 
 
22735 
  def validate(self):
22736 
    return
22737 
 
22738 
 
22739 
  def __repr__(self):
22740 
    L = ['%s=%r' % (key, value)
22741 
      for key, value in self.__dict__.iteritems()]
22742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22743 
 
22744 
  def __eq__(self, other):
22745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22746 
 
22747 
  def __ne__(self, other):
22748 
    return not (self == other)
22749 
 
22750 
class acceptOrdersForItemId_result:
22751 
  """
22752 
  Attributes:
22753 
   - success
22754 
   - ex
22755 
  """
22756 
 
22757 
  thrift_spec = (
22758 
    (0, TType.BOOL, 'success', None, None, ), # 0
22759 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22760 
  )
22761 
 
22762 
  def __init__(self, success=None, ex=None,):
22763 
    self.success = success
22764 
    self.ex = ex
22765 
 
22766 
  def read(self, iprot):
22767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22769 
      return
22770 
    iprot.readStructBegin()
22771 
    while True:
22772 
      (fname, ftype, fid) = iprot.readFieldBegin()
22773 
      if ftype == TType.STOP:
22774 
        break
22775 
      if fid == 0:
22776 
        if ftype == TType.BOOL:
22777 
          self.success = iprot.readBool();
22778 
        else:
22779 
          iprot.skip(ftype)
22780 
      elif fid == 1:
22781 
        if ftype == TType.STRUCT:
22782 
          self.ex = TransactionServiceException()
22783 
          self.ex.read(iprot)
22784 
        else:
22785 
          iprot.skip(ftype)
22786 
      else:
22787 
        iprot.skip(ftype)
22788 
      iprot.readFieldEnd()
22789 
    iprot.readStructEnd()
22790 
 
22791 
  def write(self, oprot):
22792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22794 
      return
22795 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
22796 
    if self.success is not None:
22797 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22798 
      oprot.writeBool(self.success)
22799 
      oprot.writeFieldEnd()
22800 
    if self.ex is not None:
22801 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22802 
      self.ex.write(oprot)
22803 
      oprot.writeFieldEnd()
22804 
    oprot.writeFieldStop()
22805 
    oprot.writeStructEnd()
22806 
 
22807 
  def validate(self):
22808 
    return
22809 
 
22810 
 
22811 
  def __repr__(self):
22812 
    L = ['%s=%r' % (key, value)
22813 
      for key, value in self.__dict__.iteritems()]
22814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22815 
 
22816 
  def __eq__(self, other):
22817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22818 
 
22819 
  def __ne__(self, other):
22820 
    return not (self == other)
4303 rajveer 22821 
 
22822 
class markOrdersAsPORaised_args:
22823 
  """
22824 
  Attributes:
22825 
   - vendorId
22826 
   - itemId
22827 
   - quantity
22828 
   - estimate
4369 rajveer 22829 
   - isReminder
4303 rajveer 22830 
  """
22831 
 
22832 
  thrift_spec = (
22833 
    None, # 0
22834 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22835 
    (2, TType.I64, 'itemId', None, None, ), # 2
22836 
    (3, TType.I64, 'quantity', None, None, ), # 3
22837 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22838 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22839 
  )
22840 
 
4369 rajveer 22841 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22842 
    self.vendorId = vendorId
22843 
    self.itemId = itemId
22844 
    self.quantity = quantity
22845 
    self.estimate = estimate
4369 rajveer 22846 
    self.isReminder = isReminder
4303 rajveer 22847 
 
22848 
  def read(self, iprot):
22849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22851 
      return
22852 
    iprot.readStructBegin()
22853 
    while True:
22854 
      (fname, ftype, fid) = iprot.readFieldBegin()
22855 
      if ftype == TType.STOP:
22856 
        break
22857 
      if fid == 1:
22858 
        if ftype == TType.I64:
22859 
          self.vendorId = iprot.readI64();
22860 
        else:
22861 
          iprot.skip(ftype)
22862 
      elif fid == 2:
22863 
        if ftype == TType.I64:
22864 
          self.itemId = iprot.readI64();
22865 
        else:
22866 
          iprot.skip(ftype)
22867 
      elif fid == 3:
22868 
        if ftype == TType.I64:
22869 
          self.quantity = iprot.readI64();
22870 
        else:
22871 
          iprot.skip(ftype)
22872 
      elif fid == 4:
22873 
        if ftype == TType.I64:
22874 
          self.estimate = iprot.readI64();
22875 
        else:
22876 
          iprot.skip(ftype)
4369 rajveer 22877 
      elif fid == 5:
22878 
        if ftype == TType.BOOL:
22879 
          self.isReminder = iprot.readBool();
22880 
        else:
22881 
          iprot.skip(ftype)
4303 rajveer 22882 
      else:
22883 
        iprot.skip(ftype)
22884 
      iprot.readFieldEnd()
22885 
    iprot.readStructEnd()
22886 
 
22887 
  def write(self, oprot):
22888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22890 
      return
22891 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22892 
    if self.vendorId is not None:
22893 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22894 
      oprot.writeI64(self.vendorId)
22895 
      oprot.writeFieldEnd()
22896 
    if self.itemId is not None:
22897 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22898 
      oprot.writeI64(self.itemId)
22899 
      oprot.writeFieldEnd()
22900 
    if self.quantity is not None:
22901 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22902 
      oprot.writeI64(self.quantity)
22903 
      oprot.writeFieldEnd()
22904 
    if self.estimate is not None:
22905 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22906 
      oprot.writeI64(self.estimate)
22907 
      oprot.writeFieldEnd()
4369 rajveer 22908 
    if self.isReminder is not None:
22909 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22910 
      oprot.writeBool(self.isReminder)
22911 
      oprot.writeFieldEnd()
4303 rajveer 22912 
    oprot.writeFieldStop()
22913 
    oprot.writeStructEnd()
22914 
 
22915 
  def validate(self):
22916 
    return
22917 
 
22918 
 
22919 
  def __repr__(self):
22920 
    L = ['%s=%r' % (key, value)
22921 
      for key, value in self.__dict__.iteritems()]
22922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22923 
 
22924 
  def __eq__(self, other):
22925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22926 
 
22927 
  def __ne__(self, other):
22928 
    return not (self == other)
22929 
 
22930 
class markOrdersAsPORaised_result:
22931 
  """
22932 
  Attributes:
22933 
   - ex
22934 
  """
22935 
 
22936 
  thrift_spec = (
22937 
    None, # 0
22938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22939 
  )
22940 
 
22941 
  def __init__(self, ex=None,):
22942 
    self.ex = ex
22943 
 
22944 
  def read(self, iprot):
22945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22947 
      return
22948 
    iprot.readStructBegin()
22949 
    while True:
22950 
      (fname, ftype, fid) = iprot.readFieldBegin()
22951 
      if ftype == TType.STOP:
22952 
        break
22953 
      if fid == 1:
22954 
        if ftype == TType.STRUCT:
22955 
          self.ex = TransactionServiceException()
22956 
          self.ex.read(iprot)
22957 
        else:
22958 
          iprot.skip(ftype)
22959 
      else:
22960 
        iprot.skip(ftype)
22961 
      iprot.readFieldEnd()
22962 
    iprot.readStructEnd()
22963 
 
22964 
  def write(self, oprot):
22965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22967 
      return
22968 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22969 
    if self.ex is not None:
22970 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22971 
      self.ex.write(oprot)
22972 
      oprot.writeFieldEnd()
22973 
    oprot.writeFieldStop()
22974 
    oprot.writeStructEnd()
22975 
 
22976 
  def validate(self):
22977 
    return
22978 
 
22979 
 
22980 
  def __repr__(self):
22981 
    L = ['%s=%r' % (key, value)
22982 
      for key, value in self.__dict__.iteritems()]
22983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22984 
 
22985 
  def __eq__(self, other):
22986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22987 
 
22988 
  def __ne__(self, other):
22989 
    return not (self == other)
22990 
 
22991 
class markOrdersAsReversalInitiated_args:
22992 
  """
22993 
  Attributes:
22994 
   - vendorId
22995 
   - itemId
22996 
   - quantity
22997 
   - estimate
4369 rajveer 22998 
   - isReminder
4303 rajveer 22999 
  """
23000 
 
23001 
  thrift_spec = (
23002 
    None, # 0
23003 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23004 
    (2, TType.I64, 'itemId', None, None, ), # 2
23005 
    (3, TType.I64, 'quantity', None, None, ), # 3
23006 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 23007 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 23008 
  )
23009 
 
4369 rajveer 23010 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 23011 
    self.vendorId = vendorId
23012 
    self.itemId = itemId
23013 
    self.quantity = quantity
23014 
    self.estimate = estimate
4369 rajveer 23015 
    self.isReminder = isReminder
4303 rajveer 23016 
 
23017 
  def read(self, iprot):
23018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23020 
      return
23021 
    iprot.readStructBegin()
23022 
    while True:
23023 
      (fname, ftype, fid) = iprot.readFieldBegin()
23024 
      if ftype == TType.STOP:
23025 
        break
23026 
      if fid == 1:
23027 
        if ftype == TType.I64:
23028 
          self.vendorId = iprot.readI64();
23029 
        else:
23030 
          iprot.skip(ftype)
23031 
      elif fid == 2:
23032 
        if ftype == TType.I64:
23033 
          self.itemId = iprot.readI64();
23034 
        else:
23035 
          iprot.skip(ftype)
23036 
      elif fid == 3:
23037 
        if ftype == TType.I64:
23038 
          self.quantity = iprot.readI64();
23039 
        else:
23040 
          iprot.skip(ftype)
23041 
      elif fid == 4:
23042 
        if ftype == TType.I64:
23043 
          self.estimate = iprot.readI64();
23044 
        else:
23045 
          iprot.skip(ftype)
4369 rajveer 23046 
      elif fid == 5:
23047 
        if ftype == TType.BOOL:
23048 
          self.isReminder = iprot.readBool();
23049 
        else:
23050 
          iprot.skip(ftype)
4303 rajveer 23051 
      else:
23052 
        iprot.skip(ftype)
23053 
      iprot.readFieldEnd()
23054 
    iprot.readStructEnd()
23055 
 
23056 
  def write(self, oprot):
23057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23059 
      return
23060 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
23061 
    if self.vendorId is not None:
23062 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23063 
      oprot.writeI64(self.vendorId)
23064 
      oprot.writeFieldEnd()
23065 
    if self.itemId is not None:
23066 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
23067 
      oprot.writeI64(self.itemId)
23068 
      oprot.writeFieldEnd()
23069 
    if self.quantity is not None:
23070 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
23071 
      oprot.writeI64(self.quantity)
23072 
      oprot.writeFieldEnd()
23073 
    if self.estimate is not None:
23074 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
23075 
      oprot.writeI64(self.estimate)
23076 
      oprot.writeFieldEnd()
4369 rajveer 23077 
    if self.isReminder is not None:
23078 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
23079 
      oprot.writeBool(self.isReminder)
23080 
      oprot.writeFieldEnd()
4303 rajveer 23081 
    oprot.writeFieldStop()
23082 
    oprot.writeStructEnd()
23083 
 
23084 
  def validate(self):
23085 
    return
23086 
 
23087 
 
23088 
  def __repr__(self):
23089 
    L = ['%s=%r' % (key, value)
23090 
      for key, value in self.__dict__.iteritems()]
23091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23092 
 
23093 
  def __eq__(self, other):
23094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23095 
 
23096 
  def __ne__(self, other):
23097 
    return not (self == other)
23098 
 
23099 
class markOrdersAsReversalInitiated_result:
23100 
  """
23101 
  Attributes:
23102 
   - ex
23103 
  """
23104 
 
23105 
  thrift_spec = (
23106 
    None, # 0
23107 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23108 
  )
23109 
 
23110 
  def __init__(self, ex=None,):
23111 
    self.ex = ex
23112 
 
23113 
  def read(self, iprot):
23114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23116 
      return
23117 
    iprot.readStructBegin()
23118 
    while True:
23119 
      (fname, ftype, fid) = iprot.readFieldBegin()
23120 
      if ftype == TType.STOP:
23121 
        break
23122 
      if fid == 1:
23123 
        if ftype == TType.STRUCT:
23124 
          self.ex = TransactionServiceException()
23125 
          self.ex.read(iprot)
23126 
        else:
23127 
          iprot.skip(ftype)
23128 
      else:
23129 
        iprot.skip(ftype)
23130 
      iprot.readFieldEnd()
23131 
    iprot.readStructEnd()
23132 
 
23133 
  def write(self, oprot):
23134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23136 
      return
23137 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
23138 
    if self.ex is not None:
23139 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23140 
      self.ex.write(oprot)
23141 
      oprot.writeFieldEnd()
23142 
    oprot.writeFieldStop()
23143 
    oprot.writeStructEnd()
23144 
 
23145 
  def validate(self):
23146 
    return
23147 
 
23148 
 
23149 
  def __repr__(self):
23150 
    L = ['%s=%r' % (key, value)
23151 
      for key, value in self.__dict__.iteritems()]
23152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23153 
 
23154 
  def __eq__(self, other):
23155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23156 
 
23157 
  def __ne__(self, other):
23158 
    return not (self == other)
23159 
 
23160 
class markOrdersAsNotAvailabke_args:
23161 
  """
23162 
  Attributes:
23163 
   - vendorId
23164 
   - itemId
23165 
   - quantity
23166 
   - estimate
4369 rajveer 23167 
   - isReminder
4303 rajveer 23168 
  """
23169 
 
23170 
  thrift_spec = (
23171 
    None, # 0
23172 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23173 
    (2, TType.I64, 'itemId', None, None, ), # 2
23174 
    (3, TType.I64, 'quantity', None, None, ), # 3
23175 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 23176 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 23177 
  )
23178 
 
4369 rajveer 23179 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 23180 
    self.vendorId = vendorId
23181 
    self.itemId = itemId
23182 
    self.quantity = quantity
23183 
    self.estimate = estimate
4369 rajveer 23184 
    self.isReminder = isReminder
4303 rajveer 23185 
 
23186 
  def read(self, iprot):
23187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23189 
      return
23190 
    iprot.readStructBegin()
23191 
    while True:
23192 
      (fname, ftype, fid) = iprot.readFieldBegin()
23193 
      if ftype == TType.STOP:
23194 
        break
23195 
      if fid == 1:
23196 
        if ftype == TType.I64:
23197 
          self.vendorId = iprot.readI64();
23198 
        else:
23199 
          iprot.skip(ftype)
23200 
      elif fid == 2:
23201 
        if ftype == TType.I64:
23202 
          self.itemId = iprot.readI64();
23203 
        else:
23204 
          iprot.skip(ftype)
23205 
      elif fid == 3:
23206 
        if ftype == TType.I64:
23207 
          self.quantity = iprot.readI64();
23208 
        else:
23209 
          iprot.skip(ftype)
23210 
      elif fid == 4:
23211 
        if ftype == TType.I64:
23212 
          self.estimate = iprot.readI64();
23213 
        else:
23214 
          iprot.skip(ftype)
4369 rajveer 23215 
      elif fid == 5:
23216 
        if ftype == TType.BOOL:
23217 
          self.isReminder = iprot.readBool();
23218 
        else:
23219 
          iprot.skip(ftype)
4303 rajveer 23220 
      else:
23221 
        iprot.skip(ftype)
23222 
      iprot.readFieldEnd()
23223 
    iprot.readStructEnd()
23224 
 
23225 
  def write(self, oprot):
23226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23228 
      return
23229 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
23230 
    if self.vendorId is not None:
23231 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23232 
      oprot.writeI64(self.vendorId)
23233 
      oprot.writeFieldEnd()
23234 
    if self.itemId is not None:
23235 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
23236 
      oprot.writeI64(self.itemId)
23237 
      oprot.writeFieldEnd()
23238 
    if self.quantity is not None:
23239 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
23240 
      oprot.writeI64(self.quantity)
23241 
      oprot.writeFieldEnd()
23242 
    if self.estimate is not None:
23243 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
23244 
      oprot.writeI64(self.estimate)
23245 
      oprot.writeFieldEnd()
4369 rajveer 23246 
    if self.isReminder is not None:
23247 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
23248 
      oprot.writeBool(self.isReminder)
23249 
      oprot.writeFieldEnd()
4303 rajveer 23250 
    oprot.writeFieldStop()
23251 
    oprot.writeStructEnd()
23252 
 
23253 
  def validate(self):
23254 
    return
23255 
 
23256 
 
23257 
  def __repr__(self):
23258 
    L = ['%s=%r' % (key, value)
23259 
      for key, value in self.__dict__.iteritems()]
23260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23261 
 
23262 
  def __eq__(self, other):
23263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23264 
 
23265 
  def __ne__(self, other):
23266 
    return not (self == other)
23267 
 
23268 
class markOrdersAsNotAvailabke_result:
23269 
  """
23270 
  Attributes:
23271 
   - ex
23272 
  """
23273 
 
23274 
  thrift_spec = (
23275 
    None, # 0
23276 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23277 
  )
23278 
 
23279 
  def __init__(self, ex=None,):
23280 
    self.ex = ex
23281 
 
23282 
  def read(self, iprot):
23283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23285 
      return
23286 
    iprot.readStructBegin()
23287 
    while True:
23288 
      (fname, ftype, fid) = iprot.readFieldBegin()
23289 
      if ftype == TType.STOP:
23290 
        break
23291 
      if fid == 1:
23292 
        if ftype == TType.STRUCT:
23293 
          self.ex = TransactionServiceException()
23294 
          self.ex.read(iprot)
23295 
        else:
23296 
          iprot.skip(ftype)
23297 
      else:
23298 
        iprot.skip(ftype)
23299 
      iprot.readFieldEnd()
23300 
    iprot.readStructEnd()
23301 
 
23302 
  def write(self, oprot):
23303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23305 
      return
23306 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
23307 
    if self.ex is not None:
23308 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23309 
      self.ex.write(oprot)
23310 
      oprot.writeFieldEnd()
23311 
    oprot.writeFieldStop()
23312 
    oprot.writeStructEnd()
23313 
 
23314 
  def validate(self):
23315 
    return
23316 
 
23317 
 
23318 
  def __repr__(self):
23319 
    L = ['%s=%r' % (key, value)
23320 
      for key, value in self.__dict__.iteritems()]
23321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23322 
 
23323 
  def __eq__(self, other):
23324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23325 
 
23326 
  def __ne__(self, other):
23327 
    return not (self == other)
4369 rajveer 23328 
 
23329 
class markOrdersAsTimeout_args:
23330 
  """
23331 
  Attributes:
23332 
   - vendorId
23333 
  """
23334 
 
23335 
  thrift_spec = (
23336 
    None, # 0
23337 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23338 
  )
23339 
 
23340 
  def __init__(self, vendorId=None,):
23341 
    self.vendorId = vendorId
23342 
 
23343 
  def read(self, iprot):
23344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23346 
      return
23347 
    iprot.readStructBegin()
23348 
    while True:
23349 
      (fname, ftype, fid) = iprot.readFieldBegin()
23350 
      if ftype == TType.STOP:
23351 
        break
23352 
      if fid == 1:
23353 
        if ftype == TType.I64:
23354 
          self.vendorId = iprot.readI64();
23355 
        else:
23356 
          iprot.skip(ftype)
23357 
      else:
23358 
        iprot.skip(ftype)
23359 
      iprot.readFieldEnd()
23360 
    iprot.readStructEnd()
23361 
 
23362 
  def write(self, oprot):
23363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23365 
      return
23366 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
23367 
    if self.vendorId is not None:
23368 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23369 
      oprot.writeI64(self.vendorId)
23370 
      oprot.writeFieldEnd()
23371 
    oprot.writeFieldStop()
23372 
    oprot.writeStructEnd()
23373 
 
23374 
  def validate(self):
23375 
    return
23376 
 
23377 
 
23378 
  def __repr__(self):
23379 
    L = ['%s=%r' % (key, value)
23380 
      for key, value in self.__dict__.iteritems()]
23381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23382 
 
23383 
  def __eq__(self, other):
23384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23385 
 
23386 
  def __ne__(self, other):
23387 
    return not (self == other)
23388 
 
23389 
class markOrdersAsTimeout_result:
23390 
  """
23391 
  Attributes:
23392 
   - success
23393 
   - ex
23394 
  """
23395 
 
23396 
  thrift_spec = (
23397 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
23398 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23399 
  )
23400 
 
23401 
  def __init__(self, success=None, ex=None,):
23402 
    self.success = success
23403 
    self.ex = ex
23404 
 
23405 
  def read(self, iprot):
23406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23408 
      return
23409 
    iprot.readStructBegin()
23410 
    while True:
23411 
      (fname, ftype, fid) = iprot.readFieldBegin()
23412 
      if ftype == TType.STOP:
23413 
        break
23414 
      if fid == 0:
23415 
        if ftype == TType.MAP:
23416 
          self.success = {}
6188 rajveer 23417 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
23418 
          for _i505 in xrange(_size501):
23419 
            _key506 = iprot.readI32();
23420 
            _val507 = TimeoutSummary()
23421 
            _val507.read(iprot)
23422 
            self.success[_key506] = _val507
4369 rajveer 23423 
          iprot.readMapEnd()
23424 
        else:
23425 
          iprot.skip(ftype)
23426 
      elif fid == 1:
23427 
        if ftype == TType.STRUCT:
23428 
          self.ex = TransactionServiceException()
23429 
          self.ex.read(iprot)
23430 
        else:
23431 
          iprot.skip(ftype)
23432 
      else:
23433 
        iprot.skip(ftype)
23434 
      iprot.readFieldEnd()
23435 
    iprot.readStructEnd()
23436 
 
23437 
  def write(self, oprot):
23438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23440 
      return
23441 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
23442 
    if self.success is not None:
23443 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23444 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 23445 
      for kiter508,viter509 in self.success.items():
23446 
        oprot.writeI32(kiter508)
23447 
        viter509.write(oprot)
4369 rajveer 23448 
      oprot.writeMapEnd()
23449 
      oprot.writeFieldEnd()
23450 
    if self.ex is not None:
23451 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23452 
      self.ex.write(oprot)
23453 
      oprot.writeFieldEnd()
23454 
    oprot.writeFieldStop()
23455 
    oprot.writeStructEnd()
23456 
 
23457 
  def validate(self):
23458 
    return
23459 
 
23460 
 
23461 
  def __repr__(self):
23462 
    L = ['%s=%r' % (key, value)
23463 
      for key, value in self.__dict__.iteritems()]
23464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23465 
 
23466 
  def __eq__(self, other):
23467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23468 
 
23469 
  def __ne__(self, other):
23470 
    return not (self == other)
4386 anupam.sin 23471 
 
4662 rajveer 23472 
class markOrderAsLostInTransit_args:
23473 
  """
23474 
  Attributes:
23475 
   - orderId
23476 
  """
23477 
 
23478 
  thrift_spec = (
23479 
    None, # 0
23480 
    (1, TType.I64, 'orderId', None, None, ), # 1
23481 
  )
23482 
 
23483 
  def __init__(self, orderId=None,):
23484 
    self.orderId = orderId
23485 
 
23486 
  def read(self, iprot):
23487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23489 
      return
23490 
    iprot.readStructBegin()
23491 
    while True:
23492 
      (fname, ftype, fid) = iprot.readFieldBegin()
23493 
      if ftype == TType.STOP:
23494 
        break
23495 
      if fid == 1:
23496 
        if ftype == TType.I64:
23497 
          self.orderId = iprot.readI64();
23498 
        else:
23499 
          iprot.skip(ftype)
23500 
      else:
23501 
        iprot.skip(ftype)
23502 
      iprot.readFieldEnd()
23503 
    iprot.readStructEnd()
23504 
 
23505 
  def write(self, oprot):
23506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23508 
      return
23509 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
23510 
    if self.orderId is not None:
23511 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23512 
      oprot.writeI64(self.orderId)
23513 
      oprot.writeFieldEnd()
23514 
    oprot.writeFieldStop()
23515 
    oprot.writeStructEnd()
23516 
 
23517 
  def validate(self):
23518 
    return
23519 
 
23520 
 
23521 
  def __repr__(self):
23522 
    L = ['%s=%r' % (key, value)
23523 
      for key, value in self.__dict__.iteritems()]
23524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23525 
 
23526 
  def __eq__(self, other):
23527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23528 
 
23529 
  def __ne__(self, other):
23530 
    return not (self == other)
23531 
 
23532 
class markOrderAsLostInTransit_result:
23533 
  """
23534 
  Attributes:
23535 
   - success
23536 
   - ex
23537 
  """
23538 
 
23539 
  thrift_spec = (
23540 
    (0, TType.BOOL, 'success', None, None, ), # 0
23541 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23542 
  )
23543 
 
23544 
  def __init__(self, success=None, ex=None,):
23545 
    self.success = success
23546 
    self.ex = ex
23547 
 
23548 
  def read(self, iprot):
23549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23551 
      return
23552 
    iprot.readStructBegin()
23553 
    while True:
23554 
      (fname, ftype, fid) = iprot.readFieldBegin()
23555 
      if ftype == TType.STOP:
23556 
        break
23557 
      if fid == 0:
23558 
        if ftype == TType.BOOL:
23559 
          self.success = iprot.readBool();
23560 
        else:
23561 
          iprot.skip(ftype)
23562 
      elif fid == 1:
23563 
        if ftype == TType.STRUCT:
23564 
          self.ex = TransactionServiceException()
23565 
          self.ex.read(iprot)
23566 
        else:
23567 
          iprot.skip(ftype)
23568 
      else:
23569 
        iprot.skip(ftype)
23570 
      iprot.readFieldEnd()
23571 
    iprot.readStructEnd()
23572 
 
23573 
  def write(self, oprot):
23574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23576 
      return
23577 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
23578 
    if self.success is not None:
23579 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23580 
      oprot.writeBool(self.success)
23581 
      oprot.writeFieldEnd()
23582 
    if self.ex is not None:
23583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23584 
      self.ex.write(oprot)
23585 
      oprot.writeFieldEnd()
23586 
    oprot.writeFieldStop()
23587 
    oprot.writeStructEnd()
23588 
 
23589 
  def validate(self):
23590 
    return
23591 
 
23592 
 
23593 
  def __repr__(self):
23594 
    L = ['%s=%r' % (key, value)
23595 
      for key, value in self.__dict__.iteritems()]
23596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23597 
 
23598 
  def __eq__(self, other):
23599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23600 
 
23601 
  def __ne__(self, other):
23602 
    return not (self == other)
23603 
 
4386 anupam.sin 23604 
class getOrderForAwb_args:
23605 
  """
23606 
  Attributes:
23607 
   - awb
23608 
  """
23609 
 
23610 
  thrift_spec = (
23611 
    None, # 0
23612 
    (1, TType.STRING, 'awb', None, None, ), # 1
23613 
  )
23614 
 
23615 
  def __init__(self, awb=None,):
23616 
    self.awb = awb
23617 
 
23618 
  def read(self, iprot):
23619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23621 
      return
23622 
    iprot.readStructBegin()
23623 
    while True:
23624 
      (fname, ftype, fid) = iprot.readFieldBegin()
23625 
      if ftype == TType.STOP:
23626 
        break
23627 
      if fid == 1:
23628 
        if ftype == TType.STRING:
23629 
          self.awb = iprot.readString();
23630 
        else:
23631 
          iprot.skip(ftype)
23632 
      else:
23633 
        iprot.skip(ftype)
23634 
      iprot.readFieldEnd()
23635 
    iprot.readStructEnd()
23636 
 
23637 
  def write(self, oprot):
23638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23640 
      return
23641 
    oprot.writeStructBegin('getOrderForAwb_args')
23642 
    if self.awb is not None:
23643 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
23644 
      oprot.writeString(self.awb)
23645 
      oprot.writeFieldEnd()
23646 
    oprot.writeFieldStop()
23647 
    oprot.writeStructEnd()
23648 
 
23649 
  def validate(self):
23650 
    return
23651 
 
23652 
 
23653 
  def __repr__(self):
23654 
    L = ['%s=%r' % (key, value)
23655 
      for key, value in self.__dict__.iteritems()]
23656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23657 
 
23658 
  def __eq__(self, other):
23659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23660 
 
23661 
  def __ne__(self, other):
23662 
    return not (self == other)
23663 
 
23664 
class getOrderForAwb_result:
23665 
  """
23666 
  Attributes:
23667 
   - success
23668 
   - ex
23669 
  """
23670 
 
23671 
  thrift_spec = (
23672 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
23673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23674 
  )
23675 
 
23676 
  def __init__(self, success=None, ex=None,):
23677 
    self.success = success
23678 
    self.ex = ex
23679 
 
23680 
  def read(self, iprot):
23681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23683 
      return
23684 
    iprot.readStructBegin()
23685 
    while True:
23686 
      (fname, ftype, fid) = iprot.readFieldBegin()
23687 
      if ftype == TType.STOP:
23688 
        break
23689 
      if fid == 0:
23690 
        if ftype == TType.STRUCT:
23691 
          self.success = Order()
23692 
          self.success.read(iprot)
23693 
        else:
23694 
          iprot.skip(ftype)
23695 
      elif fid == 1:
23696 
        if ftype == TType.STRUCT:
23697 
          self.ex = TransactionServiceException()
23698 
          self.ex.read(iprot)
23699 
        else:
23700 
          iprot.skip(ftype)
23701 
      else:
23702 
        iprot.skip(ftype)
23703 
      iprot.readFieldEnd()
23704 
    iprot.readStructEnd()
23705 
 
23706 
  def write(self, oprot):
23707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23709 
      return
23710 
    oprot.writeStructBegin('getOrderForAwb_result')
23711 
    if self.success is not None:
23712 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23713 
      self.success.write(oprot)
23714 
      oprot.writeFieldEnd()
23715 
    if self.ex is not None:
23716 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23717 
      self.ex.write(oprot)
23718 
      oprot.writeFieldEnd()
23719 
    oprot.writeFieldStop()
23720 
    oprot.writeStructEnd()
23721 
 
23722 
  def validate(self):
23723 
    return
23724 
 
23725 
 
23726 
  def __repr__(self):
23727 
    L = ['%s=%r' % (key, value)
23728 
      for key, value in self.__dict__.iteritems()]
23729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23730 
 
23731 
  def __eq__(self, other):
23732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23733 
 
23734 
  def __ne__(self, other):
23735 
    return not (self == other)
4506 phani.kuma 23736 
 
23737 
class getOrdersForProviderForStatus_args:
23738 
  """
23739 
  Attributes:
23740 
   - logistics_provider_id
4910 phani.kuma 23741 
   - order_status_list
4506 phani.kuma 23742 
  """
23743 
 
23744 
  thrift_spec = (
23745 
    None, # 0
23746 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 23747 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 23748 
  )
23749 
 
4910 phani.kuma 23750 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 23751 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 23752 
    self.order_status_list = order_status_list
4506 phani.kuma 23753 
 
23754 
  def read(self, iprot):
23755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23757 
      return
23758 
    iprot.readStructBegin()
23759 
    while True:
23760 
      (fname, ftype, fid) = iprot.readFieldBegin()
23761 
      if ftype == TType.STOP:
23762 
        break
23763 
      if fid == 1:
23764 
        if ftype == TType.I64:
23765 
          self.logistics_provider_id = iprot.readI64();
23766 
        else:
23767 
          iprot.skip(ftype)
23768 
      elif fid == 2:
4910 phani.kuma 23769 
        if ftype == TType.LIST:
23770 
          self.order_status_list = []
6188 rajveer 23771 
          (_etype513, _size510) = iprot.readListBegin()
23772 
          for _i514 in xrange(_size510):
23773 
            _elem515 = iprot.readI32();
23774 
            self.order_status_list.append(_elem515)
4910 phani.kuma 23775 
          iprot.readListEnd()
4506 phani.kuma 23776 
        else:
23777 
          iprot.skip(ftype)
23778 
      else:
23779 
        iprot.skip(ftype)
23780 
      iprot.readFieldEnd()
23781 
    iprot.readStructEnd()
23782 
 
23783 
  def write(self, oprot):
23784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23786 
      return
23787 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
23788 
    if self.logistics_provider_id is not None:
23789 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
23790 
      oprot.writeI64(self.logistics_provider_id)
23791 
      oprot.writeFieldEnd()
4910 phani.kuma 23792 
    if self.order_status_list is not None:
23793 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
23794 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 23795 
      for iter516 in self.order_status_list:
23796 
        oprot.writeI32(iter516)
4910 phani.kuma 23797 
      oprot.writeListEnd()
4506 phani.kuma 23798 
      oprot.writeFieldEnd()
23799 
    oprot.writeFieldStop()
23800 
    oprot.writeStructEnd()
23801 
 
23802 
  def validate(self):
23803 
    return
23804 
 
23805 
 
23806 
  def __repr__(self):
23807 
    L = ['%s=%r' % (key, value)
23808 
      for key, value in self.__dict__.iteritems()]
23809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23810 
 
23811 
  def __eq__(self, other):
23812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23813 
 
23814 
  def __ne__(self, other):
23815 
    return not (self == other)
23816 
 
23817 
class getOrdersForProviderForStatus_result:
23818 
  """
23819 
  Attributes:
23820 
   - success
23821 
   - ex
23822 
  """
23823 
 
23824 
  thrift_spec = (
23825 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23827 
  )
23828 
 
23829 
  def __init__(self, success=None, ex=None,):
23830 
    self.success = success
23831 
    self.ex = ex
23832 
 
23833 
  def read(self, iprot):
23834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23836 
      return
23837 
    iprot.readStructBegin()
23838 
    while True:
23839 
      (fname, ftype, fid) = iprot.readFieldBegin()
23840 
      if ftype == TType.STOP:
23841 
        break
23842 
      if fid == 0:
23843 
        if ftype == TType.LIST:
23844 
          self.success = []
6188 rajveer 23845 
          (_etype520, _size517) = iprot.readListBegin()
23846 
          for _i521 in xrange(_size517):
23847 
            _elem522 = Order()
23848 
            _elem522.read(iprot)
23849 
            self.success.append(_elem522)
4506 phani.kuma 23850 
          iprot.readListEnd()
23851 
        else:
23852 
          iprot.skip(ftype)
23853 
      elif fid == 1:
23854 
        if ftype == TType.STRUCT:
23855 
          self.ex = TransactionServiceException()
23856 
          self.ex.read(iprot)
23857 
        else:
23858 
          iprot.skip(ftype)
23859 
      else:
23860 
        iprot.skip(ftype)
23861 
      iprot.readFieldEnd()
23862 
    iprot.readStructEnd()
23863 
 
23864 
  def write(self, oprot):
23865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23867 
      return
23868 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23869 
    if self.success is not None:
23870 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23871 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23872 
      for iter523 in self.success:
23873 
        iter523.write(oprot)
4506 phani.kuma 23874 
      oprot.writeListEnd()
23875 
      oprot.writeFieldEnd()
23876 
    if self.ex is not None:
23877 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23878 
      self.ex.write(oprot)
23879 
      oprot.writeFieldEnd()
23880 
    oprot.writeFieldStop()
23881 
    oprot.writeStructEnd()
23882 
 
23883 
  def validate(self):
23884 
    return
23885 
 
23886 
 
23887 
  def __repr__(self):
23888 
    L = ['%s=%r' % (key, value)
23889 
      for key, value in self.__dict__.iteritems()]
23890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23891 
 
23892 
  def __eq__(self, other):
23893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23894 
 
23895 
  def __ne__(self, other):
23896 
    return not (self == other)
4600 varun.gupt 23897 
 
23898 
class getBilledOrdersForVendor_args:
23899 
  """
23900 
  Attributes:
23901 
   - vendorId
23902 
   - billingDateFrom
23903 
   - billingDateTo
23904 
  """
23905 
 
23906 
  thrift_spec = (
23907 
    None, # 0
23908 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23909 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23910 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23911 
  )
23912 
 
23913 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23914 
    self.vendorId = vendorId
23915 
    self.billingDateFrom = billingDateFrom
23916 
    self.billingDateTo = billingDateTo
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 
      if fid == 1:
23928 
        if ftype == TType.I64:
23929 
          self.vendorId = iprot.readI64();
23930 
        else:
23931 
          iprot.skip(ftype)
23932 
      elif fid == 2:
23933 
        if ftype == TType.I64:
23934 
          self.billingDateFrom = iprot.readI64();
23935 
        else:
23936 
          iprot.skip(ftype)
23937 
      elif fid == 3:
23938 
        if ftype == TType.I64:
23939 
          self.billingDateTo = iprot.readI64();
23940 
        else:
23941 
          iprot.skip(ftype)
23942 
      else:
23943 
        iprot.skip(ftype)
23944 
      iprot.readFieldEnd()
23945 
    iprot.readStructEnd()
23946 
 
23947 
  def write(self, oprot):
23948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23950 
      return
23951 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23952 
    if self.vendorId is not None:
23953 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23954 
      oprot.writeI64(self.vendorId)
23955 
      oprot.writeFieldEnd()
23956 
    if self.billingDateFrom is not None:
23957 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23958 
      oprot.writeI64(self.billingDateFrom)
23959 
      oprot.writeFieldEnd()
23960 
    if self.billingDateTo is not None:
23961 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23962 
      oprot.writeI64(self.billingDateTo)
23963 
      oprot.writeFieldEnd()
23964 
    oprot.writeFieldStop()
23965 
    oprot.writeStructEnd()
23966 
 
23967 
  def validate(self):
23968 
    return
23969 
 
23970 
 
23971 
  def __repr__(self):
23972 
    L = ['%s=%r' % (key, value)
23973 
      for key, value in self.__dict__.iteritems()]
23974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23975 
 
23976 
  def __eq__(self, other):
23977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23978 
 
23979 
  def __ne__(self, other):
23980 
    return not (self == other)
23981 
 
23982 
class getBilledOrdersForVendor_result:
23983 
  """
23984 
  Attributes:
23985 
   - success
23986 
   - ex
23987 
  """
23988 
 
23989 
  thrift_spec = (
23990 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23991 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23992 
  )
23993 
 
23994 
  def __init__(self, success=None, ex=None,):
23995 
    self.success = success
23996 
    self.ex = ex
23997 
 
23998 
  def read(self, iprot):
23999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24001 
      return
24002 
    iprot.readStructBegin()
24003 
    while True:
24004 
      (fname, ftype, fid) = iprot.readFieldBegin()
24005 
      if ftype == TType.STOP:
24006 
        break
24007 
      if fid == 0:
24008 
        if ftype == TType.LIST:
24009 
          self.success = []
6188 rajveer 24010 
          (_etype527, _size524) = iprot.readListBegin()
24011 
          for _i528 in xrange(_size524):
24012 
            _elem529 = Order()
24013 
            _elem529.read(iprot)
24014 
            self.success.append(_elem529)
4600 varun.gupt 24015 
          iprot.readListEnd()
24016 
        else:
24017 
          iprot.skip(ftype)
24018 
      elif fid == 1:
24019 
        if ftype == TType.STRUCT:
24020 
          self.ex = TransactionServiceException()
24021 
          self.ex.read(iprot)
24022 
        else:
24023 
          iprot.skip(ftype)
24024 
      else:
24025 
        iprot.skip(ftype)
24026 
      iprot.readFieldEnd()
24027 
    iprot.readStructEnd()
24028 
 
24029 
  def write(self, oprot):
24030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24032 
      return
24033 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
24034 
    if self.success is not None:
24035 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24036 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24037 
      for iter530 in self.success:
24038 
        iter530.write(oprot)
4600 varun.gupt 24039 
      oprot.writeListEnd()
24040 
      oprot.writeFieldEnd()
24041 
    if self.ex is not None:
24042 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24043 
      self.ex.write(oprot)
24044 
      oprot.writeFieldEnd()
24045 
    oprot.writeFieldStop()
24046 
    oprot.writeStructEnd()
24047 
 
24048 
  def validate(self):
24049 
    return
24050 
 
24051 
 
24052 
  def __repr__(self):
24053 
    L = ['%s=%r' % (key, value)
24054 
      for key, value in self.__dict__.iteritems()]
24055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24056 
 
24057 
  def __eq__(self, other):
24058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24059 
 
24060 
  def __ne__(self, other):
24061 
    return not (self == other)
24062 
 
4607 rajveer 24063 
class getSlippedSippingDateOrders_args:
24064 
 
24065 
  thrift_spec = (
24066 
  )
24067 
 
24068 
  def read(self, iprot):
24069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24071 
      return
24072 
    iprot.readStructBegin()
24073 
    while True:
24074 
      (fname, ftype, fid) = iprot.readFieldBegin()
24075 
      if ftype == TType.STOP:
24076 
        break
24077 
      else:
24078 
        iprot.skip(ftype)
24079 
      iprot.readFieldEnd()
24080 
    iprot.readStructEnd()
24081 
 
24082 
  def write(self, oprot):
24083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24085 
      return
24086 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
24087 
    oprot.writeFieldStop()
24088 
    oprot.writeStructEnd()
24089 
 
24090 
  def validate(self):
24091 
    return
24092 
 
24093 
 
24094 
  def __repr__(self):
24095 
    L = ['%s=%r' % (key, value)
24096 
      for key, value in self.__dict__.iteritems()]
24097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24098 
 
24099 
  def __eq__(self, other):
24100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24101 
 
24102 
  def __ne__(self, other):
24103 
    return not (self == other)
24104 
 
24105 
class getSlippedSippingDateOrders_result:
24106 
  """
24107 
  Attributes:
24108 
   - success
24109 
   - ex
24110 
  """
24111 
 
24112 
  thrift_spec = (
24113 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24115 
  )
24116 
 
24117 
  def __init__(self, success=None, ex=None,):
24118 
    self.success = success
24119 
    self.ex = ex
24120 
 
24121 
  def read(self, iprot):
24122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24124 
      return
24125 
    iprot.readStructBegin()
24126 
    while True:
24127 
      (fname, ftype, fid) = iprot.readFieldBegin()
24128 
      if ftype == TType.STOP:
24129 
        break
24130 
      if fid == 0:
24131 
        if ftype == TType.LIST:
24132 
          self.success = []
6188 rajveer 24133 
          (_etype534, _size531) = iprot.readListBegin()
24134 
          for _i535 in xrange(_size531):
24135 
            _elem536 = Order()
24136 
            _elem536.read(iprot)
24137 
            self.success.append(_elem536)
4607 rajveer 24138 
          iprot.readListEnd()
24139 
        else:
24140 
          iprot.skip(ftype)
24141 
      elif fid == 1:
24142 
        if ftype == TType.STRUCT:
24143 
          self.ex = TransactionServiceException()
24144 
          self.ex.read(iprot)
24145 
        else:
24146 
          iprot.skip(ftype)
24147 
      else:
24148 
        iprot.skip(ftype)
24149 
      iprot.readFieldEnd()
24150 
    iprot.readStructEnd()
24151 
 
24152 
  def write(self, oprot):
24153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24155 
      return
24156 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
24157 
    if self.success is not None:
24158 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24159 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24160 
      for iter537 in self.success:
24161 
        iter537.write(oprot)
4607 rajveer 24162 
      oprot.writeListEnd()
24163 
      oprot.writeFieldEnd()
24164 
    if self.ex is not None:
24165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24166 
      self.ex.write(oprot)
24167 
      oprot.writeFieldEnd()
24168 
    oprot.writeFieldStop()
24169 
    oprot.writeStructEnd()
24170 
 
24171 
  def validate(self):
24172 
    return
24173 
 
24174 
 
24175 
  def __repr__(self):
24176 
    L = ['%s=%r' % (key, value)
24177 
      for key, value in self.__dict__.iteritems()]
24178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24179 
 
24180 
  def __eq__(self, other):
24181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24182 
 
24183 
  def __ne__(self, other):
24184 
    return not (self == other)
24185 
 
4709 rajveer 24186 
class getCancelledOrders_args:
24187 
  """
24188 
  Attributes:
24189 
   - cancelDateFrom
24190 
   - cancelDateTo
24191 
  """
24192 
 
24193 
  thrift_spec = (
24194 
    None, # 0
24195 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
24196 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
24197 
  )
24198 
 
24199 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
24200 
    self.cancelDateFrom = cancelDateFrom
24201 
    self.cancelDateTo = cancelDateTo
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.I64:
24214 
          self.cancelDateFrom = iprot.readI64();
24215 
        else:
24216 
          iprot.skip(ftype)
24217 
      elif fid == 2:
24218 
        if ftype == TType.I64:
24219 
          self.cancelDateTo = iprot.readI64();
24220 
        else:
24221 
          iprot.skip(ftype)
24222 
      else:
24223 
        iprot.skip(ftype)
24224 
      iprot.readFieldEnd()
24225 
    iprot.readStructEnd()
24226 
 
24227 
  def write(self, oprot):
24228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24230 
      return
24231 
    oprot.writeStructBegin('getCancelledOrders_args')
24232 
    if self.cancelDateFrom is not None:
24233 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
24234 
      oprot.writeI64(self.cancelDateFrom)
24235 
      oprot.writeFieldEnd()
24236 
    if self.cancelDateTo is not None:
24237 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
24238 
      oprot.writeI64(self.cancelDateTo)
24239 
      oprot.writeFieldEnd()
24240 
    oprot.writeFieldStop()
24241 
    oprot.writeStructEnd()
24242 
 
24243 
  def validate(self):
24244 
    return
24245 
 
24246 
 
24247 
  def __repr__(self):
24248 
    L = ['%s=%r' % (key, value)
24249 
      for key, value in self.__dict__.iteritems()]
24250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24251 
 
24252 
  def __eq__(self, other):
24253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24254 
 
24255 
  def __ne__(self, other):
24256 
    return not (self == other)
24257 
 
24258 
class getCancelledOrders_result:
24259 
  """
24260 
  Attributes:
24261 
   - success
24262 
   - ex
24263 
  """
24264 
 
24265 
  thrift_spec = (
24266 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24268 
  )
24269 
 
24270 
  def __init__(self, success=None, ex=None,):
24271 
    self.success = success
24272 
    self.ex = ex
24273 
 
24274 
  def read(self, iprot):
24275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24277 
      return
24278 
    iprot.readStructBegin()
24279 
    while True:
24280 
      (fname, ftype, fid) = iprot.readFieldBegin()
24281 
      if ftype == TType.STOP:
24282 
        break
24283 
      if fid == 0:
24284 
        if ftype == TType.LIST:
24285 
          self.success = []
6188 rajveer 24286 
          (_etype541, _size538) = iprot.readListBegin()
24287 
          for _i542 in xrange(_size538):
24288 
            _elem543 = Order()
24289 
            _elem543.read(iprot)
24290 
            self.success.append(_elem543)
4709 rajveer 24291 
          iprot.readListEnd()
24292 
        else:
24293 
          iprot.skip(ftype)
24294 
      elif fid == 1:
24295 
        if ftype == TType.STRUCT:
24296 
          self.ex = TransactionServiceException()
24297 
          self.ex.read(iprot)
24298 
        else:
24299 
          iprot.skip(ftype)
24300 
      else:
24301 
        iprot.skip(ftype)
24302 
      iprot.readFieldEnd()
24303 
    iprot.readStructEnd()
24304 
 
24305 
  def write(self, oprot):
24306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24308 
      return
24309 
    oprot.writeStructBegin('getCancelledOrders_result')
24310 
    if self.success is not None:
24311 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24312 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24313 
      for iter544 in self.success:
24314 
        iter544.write(oprot)
4709 rajveer 24315 
      oprot.writeListEnd()
24316 
      oprot.writeFieldEnd()
24317 
    if self.ex is not None:
24318 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24319 
      self.ex.write(oprot)
24320 
      oprot.writeFieldEnd()
24321 
    oprot.writeFieldStop()
24322 
    oprot.writeStructEnd()
24323 
 
24324 
  def validate(self):
24325 
    return
24326 
 
24327 
 
24328 
  def __repr__(self):
24329 
    L = ['%s=%r' % (key, value)
24330 
      for key, value in self.__dict__.iteritems()]
24331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24332 
 
24333 
  def __eq__(self, other):
24334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24335 
 
24336 
  def __ne__(self, other):
24337 
    return not (self == other)
24338 
 
4600 varun.gupt 24339 
class saveBluedartSettlements_args:
24340 
  """
24341 
  Attributes:
24342 
   - mapAWBAndAmount
24343 
  """
24344 
 
24345 
  thrift_spec = (
24346 
    None, # 0
24347 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
24348 
  )
24349 
 
24350 
  def __init__(self, mapAWBAndAmount=None,):
24351 
    self.mapAWBAndAmount = mapAWBAndAmount
24352 
 
24353 
  def read(self, iprot):
24354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24356 
      return
24357 
    iprot.readStructBegin()
24358 
    while True:
24359 
      (fname, ftype, fid) = iprot.readFieldBegin()
24360 
      if ftype == TType.STOP:
24361 
        break
24362 
      if fid == 1:
24363 
        if ftype == TType.MAP:
24364 
          self.mapAWBAndAmount = {}
6188 rajveer 24365 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
24366 
          for _i549 in xrange(_size545):
24367 
            _key550 = iprot.readI64();
24368 
            _val551 = iprot.readDouble();
24369 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 24370 
          iprot.readMapEnd()
24371 
        else:
24372 
          iprot.skip(ftype)
24373 
      else:
24374 
        iprot.skip(ftype)
24375 
      iprot.readFieldEnd()
24376 
    iprot.readStructEnd()
24377 
 
24378 
  def write(self, oprot):
24379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24381 
      return
24382 
    oprot.writeStructBegin('saveBluedartSettlements_args')
24383 
    if self.mapAWBAndAmount is not None:
24384 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
24385 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 24386 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
24387 
        oprot.writeI64(kiter552)
24388 
        oprot.writeDouble(viter553)
4600 varun.gupt 24389 
      oprot.writeMapEnd()
24390 
      oprot.writeFieldEnd()
24391 
    oprot.writeFieldStop()
24392 
    oprot.writeStructEnd()
24393 
 
24394 
  def validate(self):
24395 
    return
24396 
 
24397 
 
24398 
  def __repr__(self):
24399 
    L = ['%s=%r' % (key, value)
24400 
      for key, value in self.__dict__.iteritems()]
24401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24402 
 
24403 
  def __eq__(self, other):
24404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24405 
 
24406 
  def __ne__(self, other):
24407 
    return not (self == other)
24408 
 
24409 
class saveBluedartSettlements_result:
24410 
  """
24411 
  Attributes:
24412 
   - ex
24413 
  """
24414 
 
24415 
  thrift_spec = (
24416 
    None, # 0
24417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24418 
  )
24419 
 
24420 
  def __init__(self, ex=None,):
24421 
    self.ex = ex
24422 
 
24423 
  def read(self, iprot):
24424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24426 
      return
24427 
    iprot.readStructBegin()
24428 
    while True:
24429 
      (fname, ftype, fid) = iprot.readFieldBegin()
24430 
      if ftype == TType.STOP:
24431 
        break
24432 
      if fid == 1:
24433 
        if ftype == TType.STRUCT:
24434 
          self.ex = TransactionServiceException()
24435 
          self.ex.read(iprot)
24436 
        else:
24437 
          iprot.skip(ftype)
24438 
      else:
24439 
        iprot.skip(ftype)
24440 
      iprot.readFieldEnd()
24441 
    iprot.readStructEnd()
24442 
 
24443 
  def write(self, oprot):
24444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24446 
      return
24447 
    oprot.writeStructBegin('saveBluedartSettlements_result')
24448 
    if self.ex is not None:
24449 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24450 
      self.ex.write(oprot)
24451 
      oprot.writeFieldEnd()
24452 
    oprot.writeFieldStop()
24453 
    oprot.writeStructEnd()
24454 
 
24455 
  def validate(self):
24456 
    return
24457 
 
24458 
 
24459 
  def __repr__(self):
24460 
    L = ['%s=%r' % (key, value)
24461 
      for key, value in self.__dict__.iteritems()]
24462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24463 
 
24464 
  def __eq__(self, other):
24465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24466 
 
24467 
  def __ne__(self, other):
24468 
    return not (self == other)
24469 
 
24470 
class savePaymentSettlements_args:
24471 
  """
24472 
  Attributes:
24473 
   - settlementDate
24474 
   - paymentGatewayId
4905 varun.gupt 24475 
   - referenceId
4600 varun.gupt 24476 
   - serviceTax
24477 
   - otherCharges
24478 
   - netCollection
24479 
  """
24480 
 
24481 
  thrift_spec = (
24482 
    None, # 0
24483 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
24484 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 24485 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 24486 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
24487 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
24488 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
24489 
  )
24490 
 
4905 varun.gupt 24491 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 24492 
    self.settlementDate = settlementDate
24493 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 24494 
    self.referenceId = referenceId
4600 varun.gupt 24495 
    self.serviceTax = serviceTax
24496 
    self.otherCharges = otherCharges
24497 
    self.netCollection = netCollection
24498 
 
24499 
  def read(self, iprot):
24500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24502 
      return
24503 
    iprot.readStructBegin()
24504 
    while True:
24505 
      (fname, ftype, fid) = iprot.readFieldBegin()
24506 
      if ftype == TType.STOP:
24507 
        break
24508 
      if fid == 1:
24509 
        if ftype == TType.I64:
24510 
          self.settlementDate = iprot.readI64();
24511 
        else:
24512 
          iprot.skip(ftype)
24513 
      elif fid == 2:
24514 
        if ftype == TType.I64:
24515 
          self.paymentGatewayId = iprot.readI64();
24516 
        else:
24517 
          iprot.skip(ftype)
24518 
      elif fid == 3:
24519 
        if ftype == TType.I64:
4905 varun.gupt 24520 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24521 
        else:
24522 
          iprot.skip(ftype)
24523 
      elif fid == 4:
24524 
        if ftype == TType.DOUBLE:
24525 
          self.serviceTax = iprot.readDouble();
24526 
        else:
24527 
          iprot.skip(ftype)
24528 
      elif fid == 5:
24529 
        if ftype == TType.DOUBLE:
24530 
          self.otherCharges = iprot.readDouble();
24531 
        else:
24532 
          iprot.skip(ftype)
24533 
      elif fid == 6:
24534 
        if ftype == TType.DOUBLE:
24535 
          self.netCollection = iprot.readDouble();
24536 
        else:
24537 
          iprot.skip(ftype)
24538 
      else:
24539 
        iprot.skip(ftype)
24540 
      iprot.readFieldEnd()
24541 
    iprot.readStructEnd()
24542 
 
24543 
  def write(self, oprot):
24544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24546 
      return
24547 
    oprot.writeStructBegin('savePaymentSettlements_args')
24548 
    if self.settlementDate is not None:
24549 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
24550 
      oprot.writeI64(self.settlementDate)
24551 
      oprot.writeFieldEnd()
24552 
    if self.paymentGatewayId is not None:
24553 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
24554 
      oprot.writeI64(self.paymentGatewayId)
24555 
      oprot.writeFieldEnd()
4905 varun.gupt 24556 
    if self.referenceId is not None:
24557 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
24558 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24559 
      oprot.writeFieldEnd()
24560 
    if self.serviceTax is not None:
24561 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
24562 
      oprot.writeDouble(self.serviceTax)
24563 
      oprot.writeFieldEnd()
24564 
    if self.otherCharges is not None:
24565 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
24566 
      oprot.writeDouble(self.otherCharges)
24567 
      oprot.writeFieldEnd()
24568 
    if self.netCollection is not None:
24569 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
24570 
      oprot.writeDouble(self.netCollection)
24571 
      oprot.writeFieldEnd()
24572 
    oprot.writeFieldStop()
24573 
    oprot.writeStructEnd()
24574 
 
24575 
  def validate(self):
24576 
    return
24577 
 
24578 
 
24579 
  def __repr__(self):
24580 
    L = ['%s=%r' % (key, value)
24581 
      for key, value in self.__dict__.iteritems()]
24582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24583 
 
24584 
  def __eq__(self, other):
24585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24586 
 
24587 
  def __ne__(self, other):
24588 
    return not (self == other)
24589 
 
24590 
class savePaymentSettlements_result:
24591 
  """
24592 
  Attributes:
24593 
   - ex
24594 
  """
24595 
 
24596 
  thrift_spec = (
24597 
    None, # 0
24598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24599 
  )
24600 
 
24601 
  def __init__(self, ex=None,):
24602 
    self.ex = ex
24603 
 
24604 
  def read(self, iprot):
24605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24607 
      return
24608 
    iprot.readStructBegin()
24609 
    while True:
24610 
      (fname, ftype, fid) = iprot.readFieldBegin()
24611 
      if ftype == TType.STOP:
24612 
        break
24613 
      if fid == 1:
24614 
        if ftype == TType.STRUCT:
24615 
          self.ex = TransactionServiceException()
24616 
          self.ex.read(iprot)
24617 
        else:
24618 
          iprot.skip(ftype)
24619 
      else:
24620 
        iprot.skip(ftype)
24621 
      iprot.readFieldEnd()
24622 
    iprot.readStructEnd()
24623 
 
24624 
  def write(self, oprot):
24625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24627 
      return
24628 
    oprot.writeStructBegin('savePaymentSettlements_result')
24629 
    if self.ex is not None:
24630 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24631 
      self.ex.write(oprot)
24632 
      oprot.writeFieldEnd()
24633 
    oprot.writeFieldStop()
24634 
    oprot.writeStructEnd()
24635 
 
24636 
  def validate(self):
24637 
    return
24638 
 
24639 
 
24640 
  def __repr__(self):
24641 
    L = ['%s=%r' % (key, value)
24642 
      for key, value in self.__dict__.iteritems()]
24643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24644 
 
24645 
  def __eq__(self, other):
24646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24647 
 
24648 
  def __ne__(self, other):
24649 
    return not (self == other)
24650 
 
24651 
class saveEBSSettlementSummary_args:
24652 
  """
24653 
  Attributes:
24654 
   - settlementId
24655 
   - settlementDate
24656 
   - transactionDateFrom
24657 
   - transactionDateTo
24658 
   - amount
24659 
  """
24660 
 
24661 
  thrift_spec = (
24662 
    None, # 0
24663 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24664 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
24665 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
24666 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
24667 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
24668 
  )
24669 
 
24670 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
24671 
    self.settlementId = settlementId
24672 
    self.settlementDate = settlementDate
24673 
    self.transactionDateFrom = transactionDateFrom
24674 
    self.transactionDateTo = transactionDateTo
24675 
    self.amount = amount
24676 
 
24677 
  def read(self, iprot):
24678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24680 
      return
24681 
    iprot.readStructBegin()
24682 
    while True:
24683 
      (fname, ftype, fid) = iprot.readFieldBegin()
24684 
      if ftype == TType.STOP:
24685 
        break
24686 
      if fid == 1:
24687 
        if ftype == TType.I64:
24688 
          self.settlementId = iprot.readI64();
24689 
        else:
24690 
          iprot.skip(ftype)
24691 
      elif fid == 2:
24692 
        if ftype == TType.I64:
24693 
          self.settlementDate = iprot.readI64();
24694 
        else:
24695 
          iprot.skip(ftype)
24696 
      elif fid == 3:
24697 
        if ftype == TType.I64:
24698 
          self.transactionDateFrom = iprot.readI64();
24699 
        else:
24700 
          iprot.skip(ftype)
24701 
      elif fid == 4:
24702 
        if ftype == TType.I64:
24703 
          self.transactionDateTo = iprot.readI64();
24704 
        else:
24705 
          iprot.skip(ftype)
24706 
      elif fid == 5:
24707 
        if ftype == TType.DOUBLE:
24708 
          self.amount = iprot.readDouble();
24709 
        else:
24710 
          iprot.skip(ftype)
24711 
      else:
24712 
        iprot.skip(ftype)
24713 
      iprot.readFieldEnd()
24714 
    iprot.readStructEnd()
24715 
 
24716 
  def write(self, oprot):
24717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24719 
      return
24720 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
24721 
    if self.settlementId is not None:
24722 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24723 
      oprot.writeI64(self.settlementId)
24724 
      oprot.writeFieldEnd()
24725 
    if self.settlementDate is not None:
24726 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
24727 
      oprot.writeI64(self.settlementDate)
24728 
      oprot.writeFieldEnd()
24729 
    if self.transactionDateFrom is not None:
24730 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
24731 
      oprot.writeI64(self.transactionDateFrom)
24732 
      oprot.writeFieldEnd()
24733 
    if self.transactionDateTo is not None:
24734 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
24735 
      oprot.writeI64(self.transactionDateTo)
24736 
      oprot.writeFieldEnd()
24737 
    if self.amount is not None:
24738 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
24739 
      oprot.writeDouble(self.amount)
24740 
      oprot.writeFieldEnd()
24741 
    oprot.writeFieldStop()
24742 
    oprot.writeStructEnd()
24743 
 
24744 
  def validate(self):
24745 
    return
24746 
 
24747 
 
24748 
  def __repr__(self):
24749 
    L = ['%s=%r' % (key, value)
24750 
      for key, value in self.__dict__.iteritems()]
24751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24752 
 
24753 
  def __eq__(self, other):
24754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24755 
 
24756 
  def __ne__(self, other):
24757 
    return not (self == other)
24758 
 
24759 
class saveEBSSettlementSummary_result:
24760 
  """
24761 
  Attributes:
24762 
   - ex
24763 
  """
24764 
 
24765 
  thrift_spec = (
24766 
    None, # 0
24767 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24768 
  )
24769 
 
24770 
  def __init__(self, ex=None,):
24771 
    self.ex = ex
24772 
 
24773 
  def read(self, iprot):
24774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24776 
      return
24777 
    iprot.readStructBegin()
24778 
    while True:
24779 
      (fname, ftype, fid) = iprot.readFieldBegin()
24780 
      if ftype == TType.STOP:
24781 
        break
24782 
      if fid == 1:
24783 
        if ftype == TType.STRUCT:
24784 
          self.ex = TransactionServiceException()
24785 
          self.ex.read(iprot)
24786 
        else:
24787 
          iprot.skip(ftype)
24788 
      else:
24789 
        iprot.skip(ftype)
24790 
      iprot.readFieldEnd()
24791 
    iprot.readStructEnd()
24792 
 
24793 
  def write(self, oprot):
24794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24796 
      return
24797 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
24798 
    if self.ex is not None:
24799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24800 
      self.ex.write(oprot)
24801 
      oprot.writeFieldEnd()
24802 
    oprot.writeFieldStop()
24803 
    oprot.writeStructEnd()
24804 
 
24805 
  def validate(self):
24806 
    return
24807 
 
24808 
 
24809 
  def __repr__(self):
24810 
    L = ['%s=%r' % (key, value)
24811 
      for key, value in self.__dict__.iteritems()]
24812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24813 
 
24814 
  def __eq__(self, other):
24815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24816 
 
24817 
  def __ne__(self, other):
24818 
    return not (self == other)
24819 
 
5386 phani.kuma 24820 
class getSettlementForPrepaid_args:
4600 varun.gupt 24821 
  """
24822 
  Attributes:
5189 varun.gupt 24823 
   - referenceId
24824 
   - isRefund
4600 varun.gupt 24825 
  """
24826 
 
24827 
  thrift_spec = (
24828 
    None, # 0
5189 varun.gupt 24829 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24830 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24831 
  )
24832 
 
5386 phani.kuma 24833 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24834 
    self.referenceId = referenceId
24835 
    self.isRefund = isRefund
4600 varun.gupt 24836 
 
24837 
  def read(self, iprot):
24838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24840 
      return
24841 
    iprot.readStructBegin()
24842 
    while True:
24843 
      (fname, ftype, fid) = iprot.readFieldBegin()
24844 
      if ftype == TType.STOP:
24845 
        break
24846 
      if fid == 1:
24847 
        if ftype == TType.I64:
5189 varun.gupt 24848 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24849 
        else:
24850 
          iprot.skip(ftype)
5189 varun.gupt 24851 
      elif fid == 2:
24852 
        if ftype == TType.BOOL:
24853 
          self.isRefund = iprot.readBool();
24854 
        else:
24855 
          iprot.skip(ftype)
4600 varun.gupt 24856 
      else:
24857 
        iprot.skip(ftype)
24858 
      iprot.readFieldEnd()
24859 
    iprot.readStructEnd()
24860 
 
24861 
  def write(self, oprot):
24862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24864 
      return
5386 phani.kuma 24865 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24866 
    if self.referenceId is not None:
24867 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24868 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24869 
      oprot.writeFieldEnd()
5386 phani.kuma 24870 
    if self.isRefund is not None:
24871 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24872 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24873 
      oprot.writeFieldEnd()
5386 phani.kuma 24874 
    oprot.writeFieldStop()
24875 
    oprot.writeStructEnd()
24876 
 
24877 
  def validate(self):
24878 
    return
24879 
 
24880 
 
24881 
  def __repr__(self):
24882 
    L = ['%s=%r' % (key, value)
24883 
      for key, value in self.__dict__.iteritems()]
24884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24885 
 
24886 
  def __eq__(self, other):
24887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24888 
 
24889 
  def __ne__(self, other):
24890 
    return not (self == other)
24891 
 
24892 
class getSettlementForPrepaid_result:
24893 
  """
24894 
  Attributes:
24895 
   - success
24896 
   - ex
24897 
  """
24898 
 
24899 
  thrift_spec = (
24900 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24901 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24902 
  )
24903 
 
24904 
  def __init__(self, success=None, ex=None,):
24905 
    self.success = success
24906 
    self.ex = ex
24907 
 
24908 
  def read(self, iprot):
24909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24911 
      return
24912 
    iprot.readStructBegin()
24913 
    while True:
24914 
      (fname, ftype, fid) = iprot.readFieldBegin()
24915 
      if ftype == TType.STOP:
24916 
        break
24917 
      if fid == 0:
24918 
        if ftype == TType.STRUCT:
24919 
          self.success = PaymentSettlement()
24920 
          self.success.read(iprot)
24921 
        else:
24922 
          iprot.skip(ftype)
24923 
      elif fid == 1:
24924 
        if ftype == TType.STRUCT:
24925 
          self.ex = TransactionServiceException()
24926 
          self.ex.read(iprot)
24927 
        else:
24928 
          iprot.skip(ftype)
24929 
      else:
24930 
        iprot.skip(ftype)
24931 
      iprot.readFieldEnd()
24932 
    iprot.readStructEnd()
24933 
 
24934 
  def write(self, oprot):
24935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24937 
      return
24938 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24939 
    if self.success is not None:
24940 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24941 
      self.success.write(oprot)
24942 
      oprot.writeFieldEnd()
24943 
    if self.ex is not None:
24944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24945 
      self.ex.write(oprot)
24946 
      oprot.writeFieldEnd()
24947 
    oprot.writeFieldStop()
24948 
    oprot.writeStructEnd()
24949 
 
24950 
  def validate(self):
24951 
    return
24952 
 
24953 
 
24954 
  def __repr__(self):
24955 
    L = ['%s=%r' % (key, value)
24956 
      for key, value in self.__dict__.iteritems()]
24957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24958 
 
24959 
  def __eq__(self, other):
24960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24961 
 
24962 
  def __ne__(self, other):
24963 
    return not (self == other)
24964 
 
24965 
class getSettlementForCod_args:
24966 
  """
24967 
  Attributes:
24968 
   - orderId
24969 
   - isRefund
24970 
  """
24971 
 
24972 
  thrift_spec = (
24973 
    None, # 0
24974 
    (1, TType.I64, 'orderId', None, None, ), # 1
24975 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24976 
  )
24977 
 
24978 
  def __init__(self, orderId=None, isRefund=None,):
24979 
    self.orderId = orderId
24980 
    self.isRefund = isRefund
24981 
 
24982 
  def read(self, iprot):
24983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24985 
      return
24986 
    iprot.readStructBegin()
24987 
    while True:
24988 
      (fname, ftype, fid) = iprot.readFieldBegin()
24989 
      if ftype == TType.STOP:
24990 
        break
24991 
      if fid == 1:
24992 
        if ftype == TType.I64:
24993 
          self.orderId = iprot.readI64();
24994 
        else:
24995 
          iprot.skip(ftype)
24996 
      elif fid == 2:
24997 
        if ftype == TType.BOOL:
24998 
          self.isRefund = iprot.readBool();
24999 
        else:
25000 
          iprot.skip(ftype)
25001 
      else:
25002 
        iprot.skip(ftype)
25003 
      iprot.readFieldEnd()
25004 
    iprot.readStructEnd()
25005 
 
25006 
  def write(self, oprot):
25007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25009 
      return
25010 
    oprot.writeStructBegin('getSettlementForCod_args')
25011 
    if self.orderId is not None:
25012 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25013 
      oprot.writeI64(self.orderId)
25014 
      oprot.writeFieldEnd()
5189 varun.gupt 25015 
    if self.isRefund is not None:
5386 phani.kuma 25016 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 25017 
      oprot.writeBool(self.isRefund)
25018 
      oprot.writeFieldEnd()
4600 varun.gupt 25019 
    oprot.writeFieldStop()
25020 
    oprot.writeStructEnd()
25021 
 
25022 
  def validate(self):
25023 
    return
25024 
 
25025 
 
25026 
  def __repr__(self):
25027 
    L = ['%s=%r' % (key, value)
25028 
      for key, value in self.__dict__.iteritems()]
25029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25030 
 
25031 
  def __eq__(self, other):
25032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25033 
 
25034 
  def __ne__(self, other):
25035 
    return not (self == other)
25036 
 
5386 phani.kuma 25037 
class getSettlementForCod_result:
4600 varun.gupt 25038 
  """
25039 
  Attributes:
25040 
   - success
25041 
   - ex
25042 
  """
25043 
 
25044 
  thrift_spec = (
25045 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
25046 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25047 
  )
25048 
 
25049 
  def __init__(self, success=None, ex=None,):
25050 
    self.success = success
25051 
    self.ex = ex
25052 
 
25053 
  def read(self, iprot):
25054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25056 
      return
25057 
    iprot.readStructBegin()
25058 
    while True:
25059 
      (fname, ftype, fid) = iprot.readFieldBegin()
25060 
      if ftype == TType.STOP:
25061 
        break
25062 
      if fid == 0:
25063 
        if ftype == TType.STRUCT:
25064 
          self.success = PaymentSettlement()
25065 
          self.success.read(iprot)
25066 
        else:
25067 
          iprot.skip(ftype)
25068 
      elif fid == 1:
25069 
        if ftype == TType.STRUCT:
25070 
          self.ex = TransactionServiceException()
25071 
          self.ex.read(iprot)
25072 
        else:
25073 
          iprot.skip(ftype)
25074 
      else:
25075 
        iprot.skip(ftype)
25076 
      iprot.readFieldEnd()
25077 
    iprot.readStructEnd()
25078 
 
25079 
  def write(self, oprot):
25080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25082 
      return
5386 phani.kuma 25083 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 25084 
    if self.success is not None:
25085 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25086 
      self.success.write(oprot)
25087 
      oprot.writeFieldEnd()
25088 
    if self.ex is not None:
25089 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25090 
      self.ex.write(oprot)
25091 
      oprot.writeFieldEnd()
25092 
    oprot.writeFieldStop()
25093 
    oprot.writeStructEnd()
25094 
 
25095 
  def validate(self):
25096 
    return
25097 
 
25098 
 
25099 
  def __repr__(self):
25100 
    L = ['%s=%r' % (key, value)
25101 
      for key, value in self.__dict__.iteritems()]
25102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25103 
 
25104 
  def __eq__(self, other):
25105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25106 
 
25107 
  def __ne__(self, other):
25108 
    return not (self == other)
25109 
 
25110 
class getEBSSettlementSummaries_args:
25111 
 
25112 
  thrift_spec = (
25113 
  )
25114 
 
25115 
  def read(self, iprot):
25116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25118 
      return
25119 
    iprot.readStructBegin()
25120 
    while True:
25121 
      (fname, ftype, fid) = iprot.readFieldBegin()
25122 
      if ftype == TType.STOP:
25123 
        break
25124 
      else:
25125 
        iprot.skip(ftype)
25126 
      iprot.readFieldEnd()
25127 
    iprot.readStructEnd()
25128 
 
25129 
  def write(self, oprot):
25130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25132 
      return
25133 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
25134 
    oprot.writeFieldStop()
25135 
    oprot.writeStructEnd()
25136 
 
25137 
  def validate(self):
25138 
    return
25139 
 
25140 
 
25141 
  def __repr__(self):
25142 
    L = ['%s=%r' % (key, value)
25143 
      for key, value in self.__dict__.iteritems()]
25144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25145 
 
25146 
  def __eq__(self, other):
25147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25148 
 
25149 
  def __ne__(self, other):
25150 
    return not (self == other)
25151 
 
25152 
class getEBSSettlementSummaries_result:
25153 
  """
25154 
  Attributes:
25155 
   - success
25156 
   - ex
25157 
  """
25158 
 
25159 
  thrift_spec = (
25160 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
25161 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25162 
  )
25163 
 
25164 
  def __init__(self, success=None, ex=None,):
25165 
    self.success = success
25166 
    self.ex = ex
25167 
 
25168 
  def read(self, iprot):
25169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25171 
      return
25172 
    iprot.readStructBegin()
25173 
    while True:
25174 
      (fname, ftype, fid) = iprot.readFieldBegin()
25175 
      if ftype == TType.STOP:
25176 
        break
25177 
      if fid == 0:
25178 
        if ftype == TType.MAP:
25179 
          self.success = {}
6188 rajveer 25180 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
25181 
          for _i558 in xrange(_size554):
25182 
            _key559 = iprot.readI64();
25183 
            _val560 = iprot.readString();
25184 
            self.success[_key559] = _val560
4600 varun.gupt 25185 
          iprot.readMapEnd()
25186 
        else:
25187 
          iprot.skip(ftype)
25188 
      elif fid == 1:
25189 
        if ftype == TType.STRUCT:
25190 
          self.ex = TransactionServiceException()
25191 
          self.ex.read(iprot)
25192 
        else:
25193 
          iprot.skip(ftype)
25194 
      else:
25195 
        iprot.skip(ftype)
25196 
      iprot.readFieldEnd()
25197 
    iprot.readStructEnd()
25198 
 
25199 
  def write(self, oprot):
25200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25202 
      return
25203 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
25204 
    if self.success is not None:
25205 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25206 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 25207 
      for kiter561,viter562 in self.success.items():
25208 
        oprot.writeI64(kiter561)
25209 
        oprot.writeString(viter562)
4600 varun.gupt 25210 
      oprot.writeMapEnd()
25211 
      oprot.writeFieldEnd()
25212 
    if self.ex is not None:
25213 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25214 
      self.ex.write(oprot)
25215 
      oprot.writeFieldEnd()
25216 
    oprot.writeFieldStop()
25217 
    oprot.writeStructEnd()
25218 
 
25219 
  def validate(self):
25220 
    return
25221 
 
25222 
 
25223 
  def __repr__(self):
25224 
    L = ['%s=%r' % (key, value)
25225 
      for key, value in self.__dict__.iteritems()]
25226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25227 
 
25228 
  def __eq__(self, other):
25229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25230 
 
25231 
  def __ne__(self, other):
25232 
    return not (self == other)
25233 
 
25234 
class markEBSSettlementUploaded_args:
25235 
  """
25236 
  Attributes:
25237 
   - settlementId
25238 
  """
25239 
 
25240 
  thrift_spec = (
25241 
    None, # 0
25242 
    (1, TType.I64, 'settlementId', None, None, ), # 1
25243 
  )
25244 
 
25245 
  def __init__(self, settlementId=None,):
25246 
    self.settlementId = settlementId
25247 
 
25248 
  def read(self, iprot):
25249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25251 
      return
25252 
    iprot.readStructBegin()
25253 
    while True:
25254 
      (fname, ftype, fid) = iprot.readFieldBegin()
25255 
      if ftype == TType.STOP:
25256 
        break
25257 
      if fid == 1:
25258 
        if ftype == TType.I64:
25259 
          self.settlementId = iprot.readI64();
25260 
        else:
25261 
          iprot.skip(ftype)
25262 
      else:
25263 
        iprot.skip(ftype)
25264 
      iprot.readFieldEnd()
25265 
    iprot.readStructEnd()
25266 
 
25267 
  def write(self, oprot):
25268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25270 
      return
25271 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
25272 
    if self.settlementId is not None:
25273 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
25274 
      oprot.writeI64(self.settlementId)
25275 
      oprot.writeFieldEnd()
25276 
    oprot.writeFieldStop()
25277 
    oprot.writeStructEnd()
25278 
 
25279 
  def validate(self):
25280 
    return
25281 
 
25282 
 
25283 
  def __repr__(self):
25284 
    L = ['%s=%r' % (key, value)
25285 
      for key, value in self.__dict__.iteritems()]
25286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25287 
 
25288 
  def __eq__(self, other):
25289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25290 
 
25291 
  def __ne__(self, other):
25292 
    return not (self == other)
25293 
 
25294 
class markEBSSettlementUploaded_result:
25295 
  """
25296 
  Attributes:
25297 
   - ex
25298 
  """
25299 
 
25300 
  thrift_spec = (
25301 
    None, # 0
25302 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25303 
  )
25304 
 
25305 
  def __init__(self, ex=None,):
25306 
    self.ex = ex
25307 
 
25308 
  def read(self, iprot):
25309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25311 
      return
25312 
    iprot.readStructBegin()
25313 
    while True:
25314 
      (fname, ftype, fid) = iprot.readFieldBegin()
25315 
      if ftype == TType.STOP:
25316 
        break
25317 
      if fid == 1:
25318 
        if ftype == TType.STRUCT:
25319 
          self.ex = TransactionServiceException()
25320 
          self.ex.read(iprot)
25321 
        else:
25322 
          iprot.skip(ftype)
25323 
      else:
25324 
        iprot.skip(ftype)
25325 
      iprot.readFieldEnd()
25326 
    iprot.readStructEnd()
25327 
 
25328 
  def write(self, oprot):
25329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25331 
      return
25332 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
25333 
    if self.ex is not None:
25334 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25335 
      self.ex.write(oprot)
25336 
      oprot.writeFieldEnd()
25337 
    oprot.writeFieldStop()
25338 
    oprot.writeStructEnd()
25339 
 
25340 
  def validate(self):
25341 
    return
25342 
 
25343 
 
25344 
  def __repr__(self):
25345 
    L = ['%s=%r' % (key, value)
25346 
      for key, value in self.__dict__.iteritems()]
25347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25348 
 
25349 
  def __eq__(self, other):
25350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25351 
 
25352 
  def __ne__(self, other):
25353 
    return not (self == other)
25354 
 
25355 
class getEBSSettlementDate_args:
25356 
  """
25357 
  Attributes:
25358 
   - settlementId
25359 
  """
25360 
 
25361 
  thrift_spec = (
25362 
    None, # 0
25363 
    (1, TType.I64, 'settlementId', None, None, ), # 1
25364 
  )
25365 
 
25366 
  def __init__(self, settlementId=None,):
25367 
    self.settlementId = settlementId
25368 
 
25369 
  def read(self, iprot):
25370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25372 
      return
25373 
    iprot.readStructBegin()
25374 
    while True:
25375 
      (fname, ftype, fid) = iprot.readFieldBegin()
25376 
      if ftype == TType.STOP:
25377 
        break
25378 
      if fid == 1:
25379 
        if ftype == TType.I64:
25380 
          self.settlementId = iprot.readI64();
25381 
        else:
25382 
          iprot.skip(ftype)
25383 
      else:
25384 
        iprot.skip(ftype)
25385 
      iprot.readFieldEnd()
25386 
    iprot.readStructEnd()
25387 
 
25388 
  def write(self, oprot):
25389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25391 
      return
25392 
    oprot.writeStructBegin('getEBSSettlementDate_args')
25393 
    if self.settlementId is not None:
25394 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
25395 
      oprot.writeI64(self.settlementId)
25396 
      oprot.writeFieldEnd()
25397 
    oprot.writeFieldStop()
25398 
    oprot.writeStructEnd()
25399 
 
25400 
  def validate(self):
25401 
    return
25402 
 
25403 
 
25404 
  def __repr__(self):
25405 
    L = ['%s=%r' % (key, value)
25406 
      for key, value in self.__dict__.iteritems()]
25407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25408 
 
25409 
  def __eq__(self, other):
25410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25411 
 
25412 
  def __ne__(self, other):
25413 
    return not (self == other)
25414 
 
25415 
class getEBSSettlementDate_result:
25416 
  """
25417 
  Attributes:
25418 
   - success
25419 
   - ex
25420 
  """
25421 
 
25422 
  thrift_spec = (
25423 
    (0, TType.I64, 'success', None, None, ), # 0
25424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25425 
  )
25426 
 
25427 
  def __init__(self, success=None, ex=None,):
25428 
    self.success = success
25429 
    self.ex = ex
25430 
 
25431 
  def read(self, iprot):
25432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25434 
      return
25435 
    iprot.readStructBegin()
25436 
    while True:
25437 
      (fname, ftype, fid) = iprot.readFieldBegin()
25438 
      if ftype == TType.STOP:
25439 
        break
25440 
      if fid == 0:
25441 
        if ftype == TType.I64:
25442 
          self.success = iprot.readI64();
25443 
        else:
25444 
          iprot.skip(ftype)
25445 
      elif fid == 1:
25446 
        if ftype == TType.STRUCT:
25447 
          self.ex = TransactionServiceException()
25448 
          self.ex.read(iprot)
25449 
        else:
25450 
          iprot.skip(ftype)
25451 
      else:
25452 
        iprot.skip(ftype)
25453 
      iprot.readFieldEnd()
25454 
    iprot.readStructEnd()
25455 
 
25456 
  def write(self, oprot):
25457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25459 
      return
25460 
    oprot.writeStructBegin('getEBSSettlementDate_result')
25461 
    if self.success is not None:
25462 
      oprot.writeFieldBegin('success', TType.I64, 0)
25463 
      oprot.writeI64(self.success)
25464 
      oprot.writeFieldEnd()
25465 
    if self.ex is not None:
25466 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25467 
      self.ex.write(oprot)
25468 
      oprot.writeFieldEnd()
25469 
    oprot.writeFieldStop()
25470 
    oprot.writeStructEnd()
25471 
 
25472 
  def validate(self):
25473 
    return
25474 
 
25475 
 
25476 
  def __repr__(self):
25477 
    L = ['%s=%r' % (key, value)
25478 
      for key, value in self.__dict__.iteritems()]
25479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25480 
 
25481 
  def __eq__(self, other):
25482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25483 
 
25484 
  def __ne__(self, other):
25485 
    return not (self == other)
4715 varun.gupt 25486 
 
25487 
class getSettlementsByDate_args:
25488 
  """
25489 
  Attributes:
25490 
   - settlementDateFrom
25491 
   - settlementDateTo
25492 
   - isRefund
25493 
  """
25494 
 
25495 
  thrift_spec = (
25496 
    None, # 0
25497 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
25498 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
25499 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
25500 
  )
25501 
 
25502 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
25503 
    self.settlementDateFrom = settlementDateFrom
25504 
    self.settlementDateTo = settlementDateTo
25505 
    self.isRefund = isRefund
25506 
 
25507 
  def read(self, iprot):
25508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25510 
      return
25511 
    iprot.readStructBegin()
25512 
    while True:
25513 
      (fname, ftype, fid) = iprot.readFieldBegin()
25514 
      if ftype == TType.STOP:
25515 
        break
25516 
      if fid == 1:
25517 
        if ftype == TType.I64:
25518 
          self.settlementDateFrom = iprot.readI64();
25519 
        else:
25520 
          iprot.skip(ftype)
25521 
      elif fid == 2:
25522 
        if ftype == TType.I64:
25523 
          self.settlementDateTo = iprot.readI64();
25524 
        else:
25525 
          iprot.skip(ftype)
25526 
      elif fid == 3:
25527 
        if ftype == TType.BOOL:
25528 
          self.isRefund = iprot.readBool();
25529 
        else:
25530 
          iprot.skip(ftype)
25531 
      else:
25532 
        iprot.skip(ftype)
25533 
      iprot.readFieldEnd()
25534 
    iprot.readStructEnd()
25535 
 
25536 
  def write(self, oprot):
25537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25539 
      return
25540 
    oprot.writeStructBegin('getSettlementsByDate_args')
25541 
    if self.settlementDateFrom is not None:
25542 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
25543 
      oprot.writeI64(self.settlementDateFrom)
25544 
      oprot.writeFieldEnd()
25545 
    if self.settlementDateTo is not None:
25546 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
25547 
      oprot.writeI64(self.settlementDateTo)
25548 
      oprot.writeFieldEnd()
25549 
    if self.isRefund is not None:
25550 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
25551 
      oprot.writeBool(self.isRefund)
25552 
      oprot.writeFieldEnd()
25553 
    oprot.writeFieldStop()
25554 
    oprot.writeStructEnd()
25555 
 
25556 
  def validate(self):
25557 
    return
25558 
 
25559 
 
25560 
  def __repr__(self):
25561 
    L = ['%s=%r' % (key, value)
25562 
      for key, value in self.__dict__.iteritems()]
25563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25564 
 
25565 
  def __eq__(self, other):
25566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25567 
 
25568 
  def __ne__(self, other):
25569 
    return not (self == other)
25570 
 
25571 
class getSettlementsByDate_result:
25572 
  """
25573 
  Attributes:
25574 
   - success
25575 
   - ex
25576 
  """
25577 
 
25578 
  thrift_spec = (
25579 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
25580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25581 
  )
25582 
 
25583 
  def __init__(self, success=None, ex=None,):
25584 
    self.success = success
25585 
    self.ex = ex
25586 
 
25587 
  def read(self, iprot):
25588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25590 
      return
25591 
    iprot.readStructBegin()
25592 
    while True:
25593 
      (fname, ftype, fid) = iprot.readFieldBegin()
25594 
      if ftype == TType.STOP:
25595 
        break
25596 
      if fid == 0:
25597 
        if ftype == TType.LIST:
25598 
          self.success = []
6188 rajveer 25599 
          (_etype566, _size563) = iprot.readListBegin()
25600 
          for _i567 in xrange(_size563):
25601 
            _elem568 = PaymentSettlement()
25602 
            _elem568.read(iprot)
25603 
            self.success.append(_elem568)
4715 varun.gupt 25604 
          iprot.readListEnd()
25605 
        else:
25606 
          iprot.skip(ftype)
25607 
      elif fid == 1:
25608 
        if ftype == TType.STRUCT:
25609 
          self.ex = TransactionServiceException()
25610 
          self.ex.read(iprot)
25611 
        else:
25612 
          iprot.skip(ftype)
25613 
      else:
25614 
        iprot.skip(ftype)
25615 
      iprot.readFieldEnd()
25616 
    iprot.readStructEnd()
25617 
 
25618 
  def write(self, oprot):
25619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25621 
      return
25622 
    oprot.writeStructBegin('getSettlementsByDate_result')
25623 
    if self.success is not None:
25624 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25625 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25626 
      for iter569 in self.success:
25627 
        iter569.write(oprot)
4715 varun.gupt 25628 
      oprot.writeListEnd()
25629 
      oprot.writeFieldEnd()
25630 
    if self.ex is not None:
25631 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25632 
      self.ex.write(oprot)
25633 
      oprot.writeFieldEnd()
25634 
    oprot.writeFieldStop()
25635 
    oprot.writeStructEnd()
25636 
 
25637 
  def validate(self):
25638 
    return
25639 
 
25640 
 
25641 
  def __repr__(self):
25642 
    L = ['%s=%r' % (key, value)
25643 
      for key, value in self.__dict__.iteritems()]
25644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25645 
 
25646 
  def __eq__(self, other):
25647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25648 
 
25649 
  def __ne__(self, other):
25650 
    return not (self == other)
25651 
 
25652 
class getReshippedOrderIds_args:
25653 
  """
25654 
  Attributes:
25655 
   - orderIds
25656 
  """
25657 
 
25658 
  thrift_spec = (
25659 
    None, # 0
25660 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
25661 
  )
25662 
 
25663 
  def __init__(self, orderIds=None,):
25664 
    self.orderIds = orderIds
25665 
 
25666 
  def read(self, iprot):
25667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25669 
      return
25670 
    iprot.readStructBegin()
25671 
    while True:
25672 
      (fname, ftype, fid) = iprot.readFieldBegin()
25673 
      if ftype == TType.STOP:
25674 
        break
25675 
      if fid == 1:
25676 
        if ftype == TType.LIST:
25677 
          self.orderIds = []
6188 rajveer 25678 
          (_etype573, _size570) = iprot.readListBegin()
25679 
          for _i574 in xrange(_size570):
25680 
            _elem575 = iprot.readI64();
25681 
            self.orderIds.append(_elem575)
4715 varun.gupt 25682 
          iprot.readListEnd()
25683 
        else:
25684 
          iprot.skip(ftype)
25685 
      else:
25686 
        iprot.skip(ftype)
25687 
      iprot.readFieldEnd()
25688 
    iprot.readStructEnd()
25689 
 
25690 
  def write(self, oprot):
25691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25693 
      return
25694 
    oprot.writeStructBegin('getReshippedOrderIds_args')
25695 
    if self.orderIds is not None:
25696 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
25697 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 25698 
      for iter576 in self.orderIds:
25699 
        oprot.writeI64(iter576)
4715 varun.gupt 25700 
      oprot.writeListEnd()
25701 
      oprot.writeFieldEnd()
25702 
    oprot.writeFieldStop()
25703 
    oprot.writeStructEnd()
25704 
 
25705 
  def validate(self):
25706 
    return
25707 
 
25708 
 
25709 
  def __repr__(self):
25710 
    L = ['%s=%r' % (key, value)
25711 
      for key, value in self.__dict__.iteritems()]
25712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25713 
 
25714 
  def __eq__(self, other):
25715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25716 
 
25717 
  def __ne__(self, other):
25718 
    return not (self == other)
25719 
 
25720 
class getReshippedOrderIds_result:
25721 
  """
25722 
  Attributes:
25723 
   - success
25724 
   - ex
25725 
  """
25726 
 
25727 
  thrift_spec = (
25728 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25730 
  )
25731 
 
25732 
  def __init__(self, success=None, ex=None,):
25733 
    self.success = success
25734 
    self.ex = ex
25735 
 
25736 
  def read(self, iprot):
25737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25739 
      return
25740 
    iprot.readStructBegin()
25741 
    while True:
25742 
      (fname, ftype, fid) = iprot.readFieldBegin()
25743 
      if ftype == TType.STOP:
25744 
        break
25745 
      if fid == 0:
25746 
        if ftype == TType.LIST:
25747 
          self.success = []
6188 rajveer 25748 
          (_etype580, _size577) = iprot.readListBegin()
25749 
          for _i581 in xrange(_size577):
25750 
            _elem582 = iprot.readI64();
25751 
            self.success.append(_elem582)
4715 varun.gupt 25752 
          iprot.readListEnd()
25753 
        else:
25754 
          iprot.skip(ftype)
25755 
      elif fid == 1:
25756 
        if ftype == TType.STRUCT:
25757 
          self.ex = TransactionServiceException()
25758 
          self.ex.read(iprot)
25759 
        else:
25760 
          iprot.skip(ftype)
25761 
      else:
25762 
        iprot.skip(ftype)
25763 
      iprot.readFieldEnd()
25764 
    iprot.readStructEnd()
25765 
 
25766 
  def write(self, oprot):
25767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25769 
      return
25770 
    oprot.writeStructBegin('getReshippedOrderIds_result')
25771 
    if self.success is not None:
25772 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25773 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25774 
      for iter583 in self.success:
25775 
        oprot.writeI64(iter583)
4715 varun.gupt 25776 
      oprot.writeListEnd()
25777 
      oprot.writeFieldEnd()
25778 
    if self.ex is not None:
25779 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25780 
      self.ex.write(oprot)
25781 
      oprot.writeFieldEnd()
25782 
    oprot.writeFieldStop()
25783 
    oprot.writeStructEnd()
25784 
 
25785 
  def validate(self):
25786 
    return
25787 
 
25788 
 
25789 
  def __repr__(self):
25790 
    L = ['%s=%r' % (key, value)
25791 
      for key, value in self.__dict__.iteritems()]
25792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25793 
 
25794 
  def __eq__(self, other):
25795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25796 
 
25797 
  def __ne__(self, other):
25798 
    return not (self == other)
4757 mandeep.dh 25799 
 
5481 phani.kuma 25800 
class getBilledOrders_args:
4875 varun.gupt 25801 
  """
25802 
  Attributes:
25803 
   - vendorId
5481 phani.kuma 25804 
   - onlyVendorNotPaid
25805 
   - billingDateFrom
25806 
   - billingDateTo
4875 varun.gupt 25807 
  """
25808 
 
25809 
  thrift_spec = (
25810 
    None, # 0
25811 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 25812 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
25813 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
25814 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 25815 
  )
25816 
 
5481 phani.kuma 25817 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 25818 
    self.vendorId = vendorId
5481 phani.kuma 25819 
    self.onlyVendorNotPaid = onlyVendorNotPaid
25820 
    self.billingDateFrom = billingDateFrom
25821 
    self.billingDateTo = billingDateTo
4875 varun.gupt 25822 
 
25823 
  def read(self, iprot):
25824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25826 
      return
25827 
    iprot.readStructBegin()
25828 
    while True:
25829 
      (fname, ftype, fid) = iprot.readFieldBegin()
25830 
      if ftype == TType.STOP:
25831 
        break
25832 
      if fid == 1:
25833 
        if ftype == TType.I64:
25834 
          self.vendorId = iprot.readI64();
25835 
        else:
25836 
          iprot.skip(ftype)
5481 phani.kuma 25837 
      elif fid == 2:
25838 
        if ftype == TType.BOOL:
25839 
          self.onlyVendorNotPaid = iprot.readBool();
25840 
        else:
25841 
          iprot.skip(ftype)
25842 
      elif fid == 3:
25843 
        if ftype == TType.I64:
25844 
          self.billingDateFrom = iprot.readI64();
25845 
        else:
25846 
          iprot.skip(ftype)
25847 
      elif fid == 4:
25848 
        if ftype == TType.I64:
25849 
          self.billingDateTo = iprot.readI64();
25850 
        else:
25851 
          iprot.skip(ftype)
4875 varun.gupt 25852 
      else:
25853 
        iprot.skip(ftype)
25854 
      iprot.readFieldEnd()
25855 
    iprot.readStructEnd()
25856 
 
25857 
  def write(self, oprot):
25858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25860 
      return
5481 phani.kuma 25861 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25862 
    if self.vendorId is not None:
25863 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25864 
      oprot.writeI64(self.vendorId)
25865 
      oprot.writeFieldEnd()
5481 phani.kuma 25866 
    if self.onlyVendorNotPaid is not None:
25867 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25868 
      oprot.writeBool(self.onlyVendorNotPaid)
25869 
      oprot.writeFieldEnd()
25870 
    if self.billingDateFrom is not None:
25871 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25872 
      oprot.writeI64(self.billingDateFrom)
25873 
      oprot.writeFieldEnd()
25874 
    if self.billingDateTo is not None:
25875 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25876 
      oprot.writeI64(self.billingDateTo)
25877 
      oprot.writeFieldEnd()
4875 varun.gupt 25878 
    oprot.writeFieldStop()
25879 
    oprot.writeStructEnd()
25880 
 
25881 
  def validate(self):
25882 
    return
25883 
 
25884 
 
25885 
  def __repr__(self):
25886 
    L = ['%s=%r' % (key, value)
25887 
      for key, value in self.__dict__.iteritems()]
25888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25889 
 
25890 
  def __eq__(self, other):
25891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25892 
 
25893 
  def __ne__(self, other):
25894 
    return not (self == other)
25895 
 
5481 phani.kuma 25896 
class getBilledOrders_result:
4875 varun.gupt 25897 
  """
25898 
  Attributes:
25899 
   - success
25900 
   - ex
25901 
  """
25902 
 
25903 
  thrift_spec = (
25904 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25906 
  )
25907 
 
25908 
  def __init__(self, success=None, ex=None,):
25909 
    self.success = success
25910 
    self.ex = ex
25911 
 
25912 
  def read(self, iprot):
25913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25915 
      return
25916 
    iprot.readStructBegin()
25917 
    while True:
25918 
      (fname, ftype, fid) = iprot.readFieldBegin()
25919 
      if ftype == TType.STOP:
25920 
        break
25921 
      if fid == 0:
25922 
        if ftype == TType.LIST:
25923 
          self.success = []
6188 rajveer 25924 
          (_etype587, _size584) = iprot.readListBegin()
25925 
          for _i588 in xrange(_size584):
25926 
            _elem589 = Order()
25927 
            _elem589.read(iprot)
25928 
            self.success.append(_elem589)
4875 varun.gupt 25929 
          iprot.readListEnd()
25930 
        else:
25931 
          iprot.skip(ftype)
25932 
      elif fid == 1:
25933 
        if ftype == TType.STRUCT:
25934 
          self.ex = TransactionServiceException()
25935 
          self.ex.read(iprot)
25936 
        else:
25937 
          iprot.skip(ftype)
25938 
      else:
25939 
        iprot.skip(ftype)
25940 
      iprot.readFieldEnd()
25941 
    iprot.readStructEnd()
25942 
 
25943 
  def write(self, oprot):
25944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25946 
      return
5481 phani.kuma 25947 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25948 
    if self.success is not None:
25949 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25950 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25951 
      for iter590 in self.success:
25952 
        iter590.write(oprot)
4875 varun.gupt 25953 
      oprot.writeListEnd()
25954 
      oprot.writeFieldEnd()
25955 
    if self.ex is not None:
25956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25957 
      self.ex.write(oprot)
25958 
      oprot.writeFieldEnd()
25959 
    oprot.writeFieldStop()
25960 
    oprot.writeStructEnd()
25961 
 
25962 
  def validate(self):
25963 
    return
25964 
 
25965 
 
25966 
  def __repr__(self):
25967 
    L = ['%s=%r' % (key, value)
25968 
      for key, value in self.__dict__.iteritems()]
25969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25970 
 
25971 
  def __eq__(self, other):
25972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25973 
 
25974 
  def __ne__(self, other):
25975 
    return not (self == other)
5031 varun.gupt 25976 
 
25977 
class getStatusDistributionOfOrders_args:
25978 
  """
25979 
  Attributes:
25980 
   - startDate
25981 
   - endDate
25982 
  """
25983 
 
25984 
  thrift_spec = (
25985 
    None, # 0
25986 
    (1, TType.I64, 'startDate', None, None, ), # 1
25987 
    (2, TType.I64, 'endDate', None, None, ), # 2
25988 
  )
25989 
 
25990 
  def __init__(self, startDate=None, endDate=None,):
25991 
    self.startDate = startDate
25992 
    self.endDate = endDate
25993 
 
25994 
  def read(self, iprot):
25995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25997 
      return
25998 
    iprot.readStructBegin()
25999 
    while True:
26000 
      (fname, ftype, fid) = iprot.readFieldBegin()
26001 
      if ftype == TType.STOP:
26002 
        break
26003 
      if fid == 1:
26004 
        if ftype == TType.I64:
26005 
          self.startDate = iprot.readI64();
26006 
        else:
26007 
          iprot.skip(ftype)
26008 
      elif fid == 2:
26009 
        if ftype == TType.I64:
26010 
          self.endDate = iprot.readI64();
26011 
        else:
26012 
          iprot.skip(ftype)
26013 
      else:
26014 
        iprot.skip(ftype)
26015 
      iprot.readFieldEnd()
26016 
    iprot.readStructEnd()
26017 
 
26018 
  def write(self, oprot):
26019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26021 
      return
26022 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
26023 
    if self.startDate is not None:
26024 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
26025 
      oprot.writeI64(self.startDate)
26026 
      oprot.writeFieldEnd()
26027 
    if self.endDate is not None:
26028 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
26029 
      oprot.writeI64(self.endDate)
26030 
      oprot.writeFieldEnd()
26031 
    oprot.writeFieldStop()
26032 
    oprot.writeStructEnd()
26033 
 
26034 
  def validate(self):
26035 
    return
26036 
 
26037 
 
26038 
  def __repr__(self):
26039 
    L = ['%s=%r' % (key, value)
26040 
      for key, value in self.__dict__.iteritems()]
26041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26042 
 
26043 
  def __eq__(self, other):
26044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26045 
 
26046 
  def __ne__(self, other):
26047 
    return not (self == other)
26048 
 
26049 
class getStatusDistributionOfOrders_result:
26050 
  """
26051 
  Attributes:
26052 
   - success
26053 
   - ex
26054 
  """
26055 
 
26056 
  thrift_spec = (
26057 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
26058 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26059 
  )
26060 
 
26061 
  def __init__(self, success=None, ex=None,):
26062 
    self.success = success
26063 
    self.ex = ex
26064 
 
26065 
  def read(self, iprot):
26066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26068 
      return
26069 
    iprot.readStructBegin()
26070 
    while True:
26071 
      (fname, ftype, fid) = iprot.readFieldBegin()
26072 
      if ftype == TType.STOP:
26073 
        break
26074 
      if fid == 0:
26075 
        if ftype == TType.MAP:
26076 
          self.success = {}
6188 rajveer 26077 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
26078 
          for _i595 in xrange(_size591):
26079 
            _key596 = iprot.readI64();
26080 
            _val597 = iprot.readI64();
26081 
            self.success[_key596] = _val597
5031 varun.gupt 26082 
          iprot.readMapEnd()
26083 
        else:
26084 
          iprot.skip(ftype)
26085 
      elif fid == 1:
26086 
        if ftype == TType.STRUCT:
26087 
          self.ex = TransactionServiceException()
26088 
          self.ex.read(iprot)
26089 
        else:
26090 
          iprot.skip(ftype)
26091 
      else:
26092 
        iprot.skip(ftype)
26093 
      iprot.readFieldEnd()
26094 
    iprot.readStructEnd()
26095 
 
26096 
  def write(self, oprot):
26097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26099 
      return
26100 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
26101 
    if self.success is not None:
26102 
      oprot.writeFieldBegin('success', TType.MAP, 0)
26103 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 26104 
      for kiter598,viter599 in self.success.items():
26105 
        oprot.writeI64(kiter598)
26106 
        oprot.writeI64(viter599)
5031 varun.gupt 26107 
      oprot.writeMapEnd()
26108 
      oprot.writeFieldEnd()
26109 
    if self.ex is not None:
26110 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26111 
      self.ex.write(oprot)
26112 
      oprot.writeFieldEnd()
26113 
    oprot.writeFieldStop()
26114 
    oprot.writeStructEnd()
26115 
 
26116 
  def validate(self):
26117 
    return
26118 
 
26119 
 
26120 
  def __repr__(self):
26121 
    L = ['%s=%r' % (key, value)
26122 
      for key, value in self.__dict__.iteritems()]
26123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26124 
 
26125 
  def __eq__(self, other):
26126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26127 
 
26128 
  def __ne__(self, other):
26129 
    return not (self == other)
5067 varun.gupt 26130 
 
26131 
class getOrderIdsForStatus_args:
26132 
  """
26133 
  Attributes:
26134 
   - status
26135 
   - startDatetime
26136 
   - endDatetime
26137 
  """
26138 
 
26139 
  thrift_spec = (
26140 
    None, # 0
26141 
    (1, TType.I64, 'status', None, None, ), # 1
26142 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
26143 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
26144 
  )
26145 
 
26146 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
26147 
    self.status = status
26148 
    self.startDatetime = startDatetime
26149 
    self.endDatetime = endDatetime
26150 
 
26151 
  def read(self, iprot):
26152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26154 
      return
26155 
    iprot.readStructBegin()
26156 
    while True:
26157 
      (fname, ftype, fid) = iprot.readFieldBegin()
26158 
      if ftype == TType.STOP:
26159 
        break
26160 
      if fid == 1:
26161 
        if ftype == TType.I64:
26162 
          self.status = iprot.readI64();
26163 
        else:
26164 
          iprot.skip(ftype)
26165 
      elif fid == 2:
26166 
        if ftype == TType.I64:
26167 
          self.startDatetime = iprot.readI64();
26168 
        else:
26169 
          iprot.skip(ftype)
26170 
      elif fid == 3:
26171 
        if ftype == TType.I64:
26172 
          self.endDatetime = iprot.readI64();
26173 
        else:
26174 
          iprot.skip(ftype)
26175 
      else:
26176 
        iprot.skip(ftype)
26177 
      iprot.readFieldEnd()
26178 
    iprot.readStructEnd()
26179 
 
26180 
  def write(self, oprot):
26181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26183 
      return
26184 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
26185 
    if self.status is not None:
26186 
      oprot.writeFieldBegin('status', TType.I64, 1)
26187 
      oprot.writeI64(self.status)
26188 
      oprot.writeFieldEnd()
26189 
    if self.startDatetime is not None:
26190 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
26191 
      oprot.writeI64(self.startDatetime)
26192 
      oprot.writeFieldEnd()
26193 
    if self.endDatetime is not None:
26194 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
26195 
      oprot.writeI64(self.endDatetime)
26196 
      oprot.writeFieldEnd()
26197 
    oprot.writeFieldStop()
26198 
    oprot.writeStructEnd()
26199 
 
26200 
  def validate(self):
26201 
    return
26202 
 
26203 
 
26204 
  def __repr__(self):
26205 
    L = ['%s=%r' % (key, value)
26206 
      for key, value in self.__dict__.iteritems()]
26207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26208 
 
26209 
  def __eq__(self, other):
26210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26211 
 
26212 
  def __ne__(self, other):
26213 
    return not (self == other)
26214 
 
26215 
class getOrderIdsForStatus_result:
26216 
  """
26217 
  Attributes:
26218 
   - success
26219 
   - ex
26220 
  """
26221 
 
26222 
  thrift_spec = (
26223 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
26224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26225 
  )
26226 
 
26227 
  def __init__(self, success=None, ex=None,):
26228 
    self.success = success
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 == 0:
26241 
        if ftype == TType.LIST:
26242 
          self.success = []
6188 rajveer 26243 
          (_etype603, _size600) = iprot.readListBegin()
26244 
          for _i604 in xrange(_size600):
26245 
            _elem605 = iprot.readI64();
26246 
            self.success.append(_elem605)
5067 varun.gupt 26247 
          iprot.readListEnd()
26248 
        else:
26249 
          iprot.skip(ftype)
26250 
      elif fid == 1:
26251 
        if ftype == TType.STRUCT:
26252 
          self.ex = TransactionServiceException()
26253 
          self.ex.read(iprot)
26254 
        else:
26255 
          iprot.skip(ftype)
26256 
      else:
26257 
        iprot.skip(ftype)
26258 
      iprot.readFieldEnd()
26259 
    iprot.readStructEnd()
26260 
 
26261 
  def write(self, oprot):
26262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26264 
      return
26265 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
26266 
    if self.success is not None:
26267 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26268 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 26269 
      for iter606 in self.success:
26270 
        oprot.writeI64(iter606)
5067 varun.gupt 26271 
      oprot.writeListEnd()
26272 
      oprot.writeFieldEnd()
26273 
    if self.ex is not None:
26274 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26275 
      self.ex.write(oprot)
26276 
      oprot.writeFieldEnd()
26277 
    oprot.writeFieldStop()
26278 
    oprot.writeStructEnd()
26279 
 
26280 
  def validate(self):
26281 
    return
26282 
 
26283 
 
26284 
  def __repr__(self):
26285 
    L = ['%s=%r' % (key, value)
26286 
      for key, value in self.__dict__.iteritems()]
26287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26288 
 
26289 
  def __eq__(self, other):
26290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26291 
 
26292 
  def __ne__(self, other):
26293 
    return not (self == other)
5099 varun.gupt 26294 
 
5348 anupam.sin 26295 
class updateCODAgent_args:
26296 
  """
26297 
  Attributes:
26298 
   - agent
26299 
   - orderId
26300 
  """
26301 
 
26302 
  thrift_spec = (
26303 
    None, # 0
26304 
    (1, TType.STRING, 'agent', None, None, ), # 1
26305 
    (2, TType.I64, 'orderId', None, None, ), # 2
26306 
  )
26307 
 
26308 
  def __init__(self, agent=None, orderId=None,):
26309 
    self.agent = agent
26310 
    self.orderId = orderId
26311 
 
26312 
  def read(self, iprot):
26313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26315 
      return
26316 
    iprot.readStructBegin()
26317 
    while True:
26318 
      (fname, ftype, fid) = iprot.readFieldBegin()
26319 
      if ftype == TType.STOP:
26320 
        break
26321 
      if fid == 1:
26322 
        if ftype == TType.STRING:
26323 
          self.agent = iprot.readString();
26324 
        else:
26325 
          iprot.skip(ftype)
26326 
      elif fid == 2:
26327 
        if ftype == TType.I64:
26328 
          self.orderId = iprot.readI64();
26329 
        else:
26330 
          iprot.skip(ftype)
26331 
      else:
26332 
        iprot.skip(ftype)
26333 
      iprot.readFieldEnd()
26334 
    iprot.readStructEnd()
26335 
 
26336 
  def write(self, oprot):
26337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26339 
      return
26340 
    oprot.writeStructBegin('updateCODAgent_args')
26341 
    if self.agent is not None:
26342 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
26343 
      oprot.writeString(self.agent)
26344 
      oprot.writeFieldEnd()
26345 
    if self.orderId is not None:
26346 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
26347 
      oprot.writeI64(self.orderId)
26348 
      oprot.writeFieldEnd()
26349 
    oprot.writeFieldStop()
26350 
    oprot.writeStructEnd()
26351 
 
26352 
  def validate(self):
26353 
    return
26354 
 
26355 
 
26356 
  def __repr__(self):
26357 
    L = ['%s=%r' % (key, value)
26358 
      for key, value in self.__dict__.iteritems()]
26359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26360 
 
26361 
  def __eq__(self, other):
26362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26363 
 
26364 
  def __ne__(self, other):
26365 
    return not (self == other)
26366 
 
26367 
class updateCODAgent_result:
26368 
  """
26369 
  Attributes:
26370 
   - ex
26371 
  """
26372 
 
26373 
  thrift_spec = (
26374 
    None, # 0
26375 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26376 
  )
26377 
 
26378 
  def __init__(self, ex=None,):
26379 
    self.ex = ex
26380 
 
26381 
  def read(self, iprot):
26382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26384 
      return
26385 
    iprot.readStructBegin()
26386 
    while True:
26387 
      (fname, ftype, fid) = iprot.readFieldBegin()
26388 
      if ftype == TType.STOP:
26389 
        break
26390 
      if fid == 1:
26391 
        if ftype == TType.STRUCT:
26392 
          self.ex = TransactionServiceException()
26393 
          self.ex.read(iprot)
26394 
        else:
26395 
          iprot.skip(ftype)
26396 
      else:
26397 
        iprot.skip(ftype)
26398 
      iprot.readFieldEnd()
26399 
    iprot.readStructEnd()
26400 
 
26401 
  def write(self, oprot):
26402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26404 
      return
26405 
    oprot.writeStructBegin('updateCODAgent_result')
26406 
    if self.ex is not None:
26407 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26408 
      self.ex.write(oprot)
26409 
      oprot.writeFieldEnd()
26410 
    oprot.writeFieldStop()
26411 
    oprot.writeStructEnd()
26412 
 
26413 
  def validate(self):
26414 
    return
26415 
 
26416 
 
26417 
  def __repr__(self):
26418 
    L = ['%s=%r' % (key, value)
26419 
      for key, value in self.__dict__.iteritems()]
26420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26421 
 
26422 
  def __eq__(self, other):
26423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26424 
 
26425 
  def __ne__(self, other):
26426 
    return not (self == other)
26427 
 
5099 varun.gupt 26428 
class updateOrderAsPaidToVendor_args:
26429 
  """
26430 
  Attributes:
26431 
   - orderId
26432 
  """
26433 
 
26434 
  thrift_spec = (
26435 
    None, # 0
26436 
    (1, TType.I64, 'orderId', None, None, ), # 1
26437 
  )
26438 
 
26439 
  def __init__(self, orderId=None,):
26440 
    self.orderId = orderId
26441 
 
26442 
  def read(self, iprot):
26443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26445 
      return
26446 
    iprot.readStructBegin()
26447 
    while True:
26448 
      (fname, ftype, fid) = iprot.readFieldBegin()
26449 
      if ftype == TType.STOP:
26450 
        break
26451 
      if fid == 1:
26452 
        if ftype == TType.I64:
26453 
          self.orderId = iprot.readI64();
26454 
        else:
26455 
          iprot.skip(ftype)
26456 
      else:
26457 
        iprot.skip(ftype)
26458 
      iprot.readFieldEnd()
26459 
    iprot.readStructEnd()
26460 
 
26461 
  def write(self, oprot):
26462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26464 
      return
26465 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
26466 
    if self.orderId is not None:
26467 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26468 
      oprot.writeI64(self.orderId)
26469 
      oprot.writeFieldEnd()
26470 
    oprot.writeFieldStop()
26471 
    oprot.writeStructEnd()
26472 
 
26473 
  def validate(self):
26474 
    return
26475 
 
26476 
 
26477 
  def __repr__(self):
26478 
    L = ['%s=%r' % (key, value)
26479 
      for key, value in self.__dict__.iteritems()]
26480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26481 
 
26482 
  def __eq__(self, other):
26483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26484 
 
26485 
  def __ne__(self, other):
26486 
    return not (self == other)
26487 
 
26488 
class updateOrderAsPaidToVendor_result:
26489 
  """
26490 
  Attributes:
26491 
   - ex
26492 
  """
26493 
 
26494 
  thrift_spec = (
26495 
    None, # 0
26496 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26497 
  )
26498 
 
26499 
  def __init__(self, ex=None,):
26500 
    self.ex = ex
26501 
 
26502 
  def read(self, iprot):
26503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26505 
      return
26506 
    iprot.readStructBegin()
26507 
    while True:
26508 
      (fname, ftype, fid) = iprot.readFieldBegin()
26509 
      if ftype == TType.STOP:
26510 
        break
26511 
      if fid == 1:
26512 
        if ftype == TType.STRUCT:
26513 
          self.ex = TransactionServiceException()
26514 
          self.ex.read(iprot)
26515 
        else:
26516 
          iprot.skip(ftype)
26517 
      else:
26518 
        iprot.skip(ftype)
26519 
      iprot.readFieldEnd()
26520 
    iprot.readStructEnd()
26521 
 
26522 
  def write(self, oprot):
26523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26525 
      return
26526 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
26527 
    if self.ex is not None:
26528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26529 
      self.ex.write(oprot)
26530 
      oprot.writeFieldEnd()
26531 
    oprot.writeFieldStop()
26532 
    oprot.writeStructEnd()
26533 
 
26534 
  def validate(self):
26535 
    return
26536 
 
26537 
 
26538 
  def __repr__(self):
26539 
    L = ['%s=%r' % (key, value)
26540 
      for key, value in self.__dict__.iteritems()]
26541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26542 
 
26543 
  def __eq__(self, other):
26544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26545 
 
26546 
  def __ne__(self, other):
26547 
    return not (self == other)
5208 varun.gupt 26548 
 
5386 phani.kuma 26549 
class updateOrderOnlyAsPaidToVendor_args:
26550 
  """
26551 
  Attributes:
26552 
   - orderId
26553 
  """
26554 
 
26555 
  thrift_spec = (
26556 
    None, # 0
26557 
    (1, TType.I64, 'orderId', None, None, ), # 1
26558 
  )
26559 
 
26560 
  def __init__(self, orderId=None,):
26561 
    self.orderId = orderId
26562 
 
26563 
  def read(self, iprot):
26564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26566 
      return
26567 
    iprot.readStructBegin()
26568 
    while True:
26569 
      (fname, ftype, fid) = iprot.readFieldBegin()
26570 
      if ftype == TType.STOP:
26571 
        break
26572 
      if fid == 1:
26573 
        if ftype == TType.I64:
26574 
          self.orderId = iprot.readI64();
26575 
        else:
26576 
          iprot.skip(ftype)
26577 
      else:
26578 
        iprot.skip(ftype)
26579 
      iprot.readFieldEnd()
26580 
    iprot.readStructEnd()
26581 
 
26582 
  def write(self, oprot):
26583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26585 
      return
26586 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
26587 
    if self.orderId is not None:
26588 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26589 
      oprot.writeI64(self.orderId)
26590 
      oprot.writeFieldEnd()
26591 
    oprot.writeFieldStop()
26592 
    oprot.writeStructEnd()
26593 
 
26594 
  def validate(self):
26595 
    return
26596 
 
26597 
 
26598 
  def __repr__(self):
26599 
    L = ['%s=%r' % (key, value)
26600 
      for key, value in self.__dict__.iteritems()]
26601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26602 
 
26603 
  def __eq__(self, other):
26604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26605 
 
26606 
  def __ne__(self, other):
26607 
    return not (self == other)
26608 
 
26609 
class updateOrderOnlyAsPaidToVendor_result:
26610 
  """
26611 
  Attributes:
26612 
   - ex
26613 
  """
26614 
 
26615 
  thrift_spec = (
26616 
    None, # 0
26617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26618 
  )
26619 
 
26620 
  def __init__(self, ex=None,):
26621 
    self.ex = ex
26622 
 
26623 
  def read(self, iprot):
26624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26626 
      return
26627 
    iprot.readStructBegin()
26628 
    while True:
26629 
      (fname, ftype, fid) = iprot.readFieldBegin()
26630 
      if ftype == TType.STOP:
26631 
        break
26632 
      if fid == 1:
26633 
        if ftype == TType.STRUCT:
26634 
          self.ex = TransactionServiceException()
26635 
          self.ex.read(iprot)
26636 
        else:
26637 
          iprot.skip(ftype)
26638 
      else:
26639 
        iprot.skip(ftype)
26640 
      iprot.readFieldEnd()
26641 
    iprot.readStructEnd()
26642 
 
26643 
  def write(self, oprot):
26644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26646 
      return
26647 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
26648 
    if self.ex is not None:
26649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26650 
      self.ex.write(oprot)
26651 
      oprot.writeFieldEnd()
26652 
    oprot.writeFieldStop()
26653 
    oprot.writeStructEnd()
26654 
 
26655 
  def validate(self):
26656 
    return
26657 
 
26658 
 
26659 
  def __repr__(self):
26660 
    L = ['%s=%r' % (key, value)
26661 
      for key, value in self.__dict__.iteritems()]
26662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26663 
 
26664 
  def __eq__(self, other):
26665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26666 
 
26667 
  def __ne__(self, other):
26668 
    return not (self == other)
26669 
 
5208 varun.gupt 26670 
class getRefundedOrdersMarkedPaid_args:
26671 
 
26672 
  thrift_spec = (
26673 
  )
26674 
 
26675 
  def read(self, iprot):
26676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26678 
      return
26679 
    iprot.readStructBegin()
26680 
    while True:
26681 
      (fname, ftype, fid) = iprot.readFieldBegin()
26682 
      if ftype == TType.STOP:
26683 
        break
26684 
      else:
26685 
        iprot.skip(ftype)
26686 
      iprot.readFieldEnd()
26687 
    iprot.readStructEnd()
26688 
 
26689 
  def write(self, oprot):
26690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26692 
      return
26693 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
26694 
    oprot.writeFieldStop()
26695 
    oprot.writeStructEnd()
26696 
 
26697 
  def validate(self):
26698 
    return
26699 
 
26700 
 
26701 
  def __repr__(self):
26702 
    L = ['%s=%r' % (key, value)
26703 
      for key, value in self.__dict__.iteritems()]
26704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26705 
 
26706 
  def __eq__(self, other):
26707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26708 
 
26709 
  def __ne__(self, other):
26710 
    return not (self == other)
26711 
 
26712 
class getRefundedOrdersMarkedPaid_result:
26713 
  """
26714 
  Attributes:
26715 
   - success
26716 
   - ex
26717 
  """
26718 
 
26719 
  thrift_spec = (
26720 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26721 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26722 
  )
26723 
 
26724 
  def __init__(self, success=None, ex=None,):
26725 
    self.success = success
26726 
    self.ex = ex
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 
          (_etype610, _size607) = iprot.readListBegin()
26741 
          for _i611 in xrange(_size607):
26742 
            _elem612 = Order()
26743 
            _elem612.read(iprot)
26744 
            self.success.append(_elem612)
5208 varun.gupt 26745 
          iprot.readListEnd()
26746 
        else:
26747 
          iprot.skip(ftype)
26748 
      elif fid == 1:
26749 
        if ftype == TType.STRUCT:
26750 
          self.ex = TransactionServiceException()
26751 
          self.ex.read(iprot)
26752 
        else:
26753 
          iprot.skip(ftype)
26754 
      else:
26755 
        iprot.skip(ftype)
26756 
      iprot.readFieldEnd()
26757 
    iprot.readStructEnd()
26758 
 
26759 
  def write(self, oprot):
26760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26762 
      return
26763 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
26764 
    if self.success is not None:
26765 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26766 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26767 
      for iter613 in self.success:
26768 
        iter613.write(oprot)
5208 varun.gupt 26769 
      oprot.writeListEnd()
26770 
      oprot.writeFieldEnd()
26771 
    if self.ex is not None:
26772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26773 
      self.ex.write(oprot)
26774 
      oprot.writeFieldEnd()
26775 
    oprot.writeFieldStop()
26776 
    oprot.writeStructEnd()
26777 
 
26778 
  def validate(self):
26779 
    return
26780 
 
26781 
 
26782 
  def __repr__(self):
26783 
    L = ['%s=%r' % (key, value)
26784 
      for key, value in self.__dict__.iteritems()]
26785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26786 
 
26787 
  def __eq__(self, other):
26788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26789 
 
26790 
  def __ne__(self, other):
26791 
    return not (self == other)
5447 anupam.sin 26792 
 
26793 
class getAllVerificationAgents_args:
26794 
  """
26795 
  Attributes:
26796 
   - minOrderId
26797 
   - maxOrderId
26798 
  """
26799 
 
26800 
  thrift_spec = (
26801 
    None, # 0
26802 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
26803 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
26804 
  )
26805 
 
26806 
  def __init__(self, minOrderId=None, maxOrderId=None,):
26807 
    self.minOrderId = minOrderId
26808 
    self.maxOrderId = maxOrderId
26809 
 
26810 
  def read(self, iprot):
26811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26813 
      return
26814 
    iprot.readStructBegin()
26815 
    while True:
26816 
      (fname, ftype, fid) = iprot.readFieldBegin()
26817 
      if ftype == TType.STOP:
26818 
        break
26819 
      if fid == 1:
26820 
        if ftype == TType.I64:
26821 
          self.minOrderId = iprot.readI64();
26822 
        else:
26823 
          iprot.skip(ftype)
26824 
      elif fid == 2:
26825 
        if ftype == TType.I64:
26826 
          self.maxOrderId = iprot.readI64();
26827 
        else:
26828 
          iprot.skip(ftype)
26829 
      else:
26830 
        iprot.skip(ftype)
26831 
      iprot.readFieldEnd()
26832 
    iprot.readStructEnd()
26833 
 
26834 
  def write(self, oprot):
26835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26837 
      return
26838 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26839 
    if self.minOrderId is not None:
26840 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26841 
      oprot.writeI64(self.minOrderId)
26842 
      oprot.writeFieldEnd()
26843 
    if self.maxOrderId is not None:
26844 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26845 
      oprot.writeI64(self.maxOrderId)
26846 
      oprot.writeFieldEnd()
26847 
    oprot.writeFieldStop()
26848 
    oprot.writeStructEnd()
26849 
 
26850 
  def validate(self):
26851 
    return
26852 
 
26853 
 
26854 
  def __repr__(self):
26855 
    L = ['%s=%r' % (key, value)
26856 
      for key, value in self.__dict__.iteritems()]
26857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26858 
 
26859 
  def __eq__(self, other):
26860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26861 
 
26862 
  def __ne__(self, other):
26863 
    return not (self == other)
26864 
 
26865 
class getAllVerificationAgents_result:
26866 
  """
26867 
  Attributes:
26868 
   - success
26869 
  """
26870 
 
26871 
  thrift_spec = (
26872 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26873 
  )
26874 
 
26875 
  def __init__(self, success=None,):
26876 
    self.success = success
26877 
 
26878 
  def read(self, iprot):
26879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26881 
      return
26882 
    iprot.readStructBegin()
26883 
    while True:
26884 
      (fname, ftype, fid) = iprot.readFieldBegin()
26885 
      if ftype == TType.STOP:
26886 
        break
26887 
      if fid == 0:
26888 
        if ftype == TType.LIST:
26889 
          self.success = []
6188 rajveer 26890 
          (_etype617, _size614) = iprot.readListBegin()
26891 
          for _i618 in xrange(_size614):
26892 
            _elem619 = CODVerificationAgent()
26893 
            _elem619.read(iprot)
26894 
            self.success.append(_elem619)
5447 anupam.sin 26895 
          iprot.readListEnd()
26896 
        else:
26897 
          iprot.skip(ftype)
26898 
      else:
26899 
        iprot.skip(ftype)
26900 
      iprot.readFieldEnd()
26901 
    iprot.readStructEnd()
26902 
 
26903 
  def write(self, oprot):
26904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26906 
      return
26907 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26908 
    if self.success is not None:
26909 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26910 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26911 
      for iter620 in self.success:
26912 
        iter620.write(oprot)
5447 anupam.sin 26913 
      oprot.writeListEnd()
26914 
      oprot.writeFieldEnd()
26915 
    oprot.writeFieldStop()
26916 
    oprot.writeStructEnd()
26917 
 
26918 
  def validate(self):
26919 
    return
26920 
 
26921 
 
26922 
  def __repr__(self):
26923 
    L = ['%s=%r' % (key, value)
26924 
      for key, value in self.__dict__.iteritems()]
26925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26926 
 
26927 
  def __eq__(self, other):
26928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26929 
 
26930 
  def __ne__(self, other):
26931 
    return not (self == other)
5527 anupam.sin 26932 
 
26933 
class getAllAttributesForOrderId_args:
26934 
  """
26935 
  Attributes:
26936 
   - orderId
26937 
  """
26938 
 
26939 
  thrift_spec = (
26940 
    None, # 0
26941 
    (1, TType.I64, 'orderId', None, None, ), # 1
26942 
  )
26943 
 
26944 
  def __init__(self, orderId=None,):
26945 
    self.orderId = orderId
26946 
 
26947 
  def read(self, iprot):
26948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26950 
      return
26951 
    iprot.readStructBegin()
26952 
    while True:
26953 
      (fname, ftype, fid) = iprot.readFieldBegin()
26954 
      if ftype == TType.STOP:
26955 
        break
26956 
      if fid == 1:
26957 
        if ftype == TType.I64:
26958 
          self.orderId = iprot.readI64();
26959 
        else:
26960 
          iprot.skip(ftype)
26961 
      else:
26962 
        iprot.skip(ftype)
26963 
      iprot.readFieldEnd()
26964 
    iprot.readStructEnd()
26965 
 
26966 
  def write(self, oprot):
26967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26969 
      return
26970 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26971 
    if self.orderId is not None:
26972 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26973 
      oprot.writeI64(self.orderId)
26974 
      oprot.writeFieldEnd()
26975 
    oprot.writeFieldStop()
26976 
    oprot.writeStructEnd()
26977 
 
26978 
  def validate(self):
26979 
    return
26980 
 
26981 
 
26982 
  def __repr__(self):
26983 
    L = ['%s=%r' % (key, value)
26984 
      for key, value in self.__dict__.iteritems()]
26985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26986 
 
26987 
  def __eq__(self, other):
26988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26989 
 
26990 
  def __ne__(self, other):
26991 
    return not (self == other)
26992 
 
26993 
class getAllAttributesForOrderId_result:
26994 
  """
26995 
  Attributes:
26996 
   - success
26997 
  """
26998 
 
26999 
  thrift_spec = (
27000 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
27001 
  )
27002 
 
27003 
  def __init__(self, success=None,):
27004 
    self.success = success
27005 
 
27006 
  def read(self, iprot):
27007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27009 
      return
27010 
    iprot.readStructBegin()
27011 
    while True:
27012 
      (fname, ftype, fid) = iprot.readFieldBegin()
27013 
      if ftype == TType.STOP:
27014 
        break
27015 
      if fid == 0:
27016 
        if ftype == TType.LIST:
27017 
          self.success = []
6188 rajveer 27018 
          (_etype624, _size621) = iprot.readListBegin()
27019 
          for _i625 in xrange(_size621):
27020 
            _elem626 = Attribute()
27021 
            _elem626.read(iprot)
27022 
            self.success.append(_elem626)
5527 anupam.sin 27023 
          iprot.readListEnd()
27024 
        else:
27025 
          iprot.skip(ftype)
27026 
      else:
27027 
        iprot.skip(ftype)
27028 
      iprot.readFieldEnd()
27029 
    iprot.readStructEnd()
27030 
 
27031 
  def write(self, oprot):
27032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27034 
      return
27035 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
27036 
    if self.success is not None:
27037 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27038 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27039 
      for iter627 in self.success:
27040 
        iter627.write(oprot)
5527 anupam.sin 27041 
      oprot.writeListEnd()
27042 
      oprot.writeFieldEnd()
27043 
    oprot.writeFieldStop()
27044 
    oprot.writeStructEnd()
27045 
 
27046 
  def validate(self):
27047 
    return
27048 
 
27049 
 
27050 
  def __repr__(self):
27051 
    L = ['%s=%r' % (key, value)
27052 
      for key, value in self.__dict__.iteritems()]
27053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27054 
 
27055 
  def __eq__(self, other):
27056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27057 
 
27058 
  def __ne__(self, other):
27059 
    return not (self == other)
27060 
 
5676 rajveer 27061 
class setOrderAttributes_args:
27062 
  """
27063 
  Attributes:
27064 
   - orderId
27065 
   - attributes
27066 
  """
27067 
 
27068 
  thrift_spec = None
27069 
  def __init__(self, orderId=None, attributes=None,):
27070 
    self.orderId = orderId
27071 
    self.attributes = attributes
27072 
 
27073 
  def read(self, iprot):
27074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27076 
      return
27077 
    iprot.readStructBegin()
27078 
    while True:
27079 
      (fname, ftype, fid) = iprot.readFieldBegin()
27080 
      if ftype == TType.STOP:
27081 
        break
27082 
      if fid == 1:
27083 
        if ftype == TType.I64:
27084 
          self.orderId = iprot.readI64();
27085 
        else:
27086 
          iprot.skip(ftype)
27087 
      elif fid == -1:
27088 
        if ftype == TType.LIST:
27089 
          self.attributes = []
6188 rajveer 27090 
          (_etype631, _size628) = iprot.readListBegin()
27091 
          for _i632 in xrange(_size628):
27092 
            _elem633 = Attribute()
27093 
            _elem633.read(iprot)
27094 
            self.attributes.append(_elem633)
5676 rajveer 27095 
          iprot.readListEnd()
27096 
        else:
27097 
          iprot.skip(ftype)
27098 
      else:
27099 
        iprot.skip(ftype)
27100 
      iprot.readFieldEnd()
27101 
    iprot.readStructEnd()
27102 
 
27103 
  def write(self, oprot):
27104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27106 
      return
27107 
    oprot.writeStructBegin('setOrderAttributes_args')
27108 
    if self.attributes is not None:
27109 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
27110 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 27111 
      for iter634 in self.attributes:
27112 
        iter634.write(oprot)
5676 rajveer 27113 
      oprot.writeListEnd()
27114 
      oprot.writeFieldEnd()
27115 
    if self.orderId is not None:
27116 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27117 
      oprot.writeI64(self.orderId)
27118 
      oprot.writeFieldEnd()
27119 
    oprot.writeFieldStop()
27120 
    oprot.writeStructEnd()
27121 
 
27122 
  def validate(self):
27123 
    return
27124 
 
27125 
 
27126 
  def __repr__(self):
27127 
    L = ['%s=%r' % (key, value)
27128 
      for key, value in self.__dict__.iteritems()]
27129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27130 
 
27131 
  def __eq__(self, other):
27132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27133 
 
27134 
  def __ne__(self, other):
27135 
    return not (self == other)
27136 
 
27137 
class setOrderAttributes_result:
27138 
 
27139 
  thrift_spec = (
27140 
  )
27141 
 
27142 
  def read(self, iprot):
27143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27145 
      return
27146 
    iprot.readStructBegin()
27147 
    while True:
27148 
      (fname, ftype, fid) = iprot.readFieldBegin()
27149 
      if ftype == TType.STOP:
27150 
        break
27151 
      else:
27152 
        iprot.skip(ftype)
27153 
      iprot.readFieldEnd()
27154 
    iprot.readStructEnd()
27155 
 
27156 
  def write(self, oprot):
27157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27159 
      return
27160 
    oprot.writeStructBegin('setOrderAttributes_result')
27161 
    oprot.writeFieldStop()
27162 
    oprot.writeStructEnd()
27163 
 
27164 
  def validate(self):
27165 
    return
27166 
 
27167 
 
27168 
  def __repr__(self):
27169 
    L = ['%s=%r' % (key, value)
27170 
      for key, value in self.__dict__.iteritems()]
27171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27172 
 
27173 
  def __eq__(self, other):
27174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27175 
 
27176 
  def __ne__(self, other):
27177 
    return not (self == other)
27178 
 
5527 anupam.sin 27179 
class setOrderAttributeForTransaction_args:
27180 
  """
27181 
  Attributes:
27182 
   - transactionId
27183 
   - attribute
27184 
  """
27185 
 
27186 
  thrift_spec = None
27187 
  def __init__(self, transactionId=None, attribute=None,):
27188 
    self.transactionId = transactionId
27189 
    self.attribute = attribute
27190 
 
27191 
  def read(self, iprot):
27192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27194 
      return
27195 
    iprot.readStructBegin()
27196 
    while True:
27197 
      (fname, ftype, fid) = iprot.readFieldBegin()
27198 
      if ftype == TType.STOP:
27199 
        break
27200 
      if fid == 1:
27201 
        if ftype == TType.I64:
27202 
          self.transactionId = iprot.readI64();
27203 
        else:
27204 
          iprot.skip(ftype)
27205 
      elif fid == -1:
27206 
        if ftype == TType.STRUCT:
27207 
          self.attribute = Attribute()
27208 
          self.attribute.read(iprot)
27209 
        else:
27210 
          iprot.skip(ftype)
27211 
      else:
27212 
        iprot.skip(ftype)
27213 
      iprot.readFieldEnd()
27214 
    iprot.readStructEnd()
27215 
 
27216 
  def write(self, oprot):
27217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27219 
      return
27220 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
27221 
    if self.attribute is not None:
27222 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
27223 
      self.attribute.write(oprot)
27224 
      oprot.writeFieldEnd()
27225 
    if self.transactionId is not None:
27226 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
27227 
      oprot.writeI64(self.transactionId)
27228 
      oprot.writeFieldEnd()
27229 
    oprot.writeFieldStop()
27230 
    oprot.writeStructEnd()
27231 
 
27232 
  def validate(self):
27233 
    return
27234 
 
27235 
 
27236 
  def __repr__(self):
27237 
    L = ['%s=%r' % (key, value)
27238 
      for key, value in self.__dict__.iteritems()]
27239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27240 
 
27241 
  def __eq__(self, other):
27242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27243 
 
27244 
  def __ne__(self, other):
27245 
    return not (self == other)
27246 
 
27247 
class setOrderAttributeForTransaction_result:
27248 
 
27249 
  thrift_spec = (
27250 
  )
27251 
 
27252 
  def read(self, iprot):
27253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27255 
      return
27256 
    iprot.readStructBegin()
27257 
    while True:
27258 
      (fname, ftype, fid) = iprot.readFieldBegin()
27259 
      if ftype == TType.STOP:
27260 
        break
27261 
      else:
27262 
        iprot.skip(ftype)
27263 
      iprot.readFieldEnd()
27264 
    iprot.readStructEnd()
27265 
 
27266 
  def write(self, oprot):
27267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27269 
      return
27270 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
27271 
    oprot.writeFieldStop()
27272 
    oprot.writeStructEnd()
27273 
 
27274 
  def validate(self):
27275 
    return
27276 
 
27277 
 
27278 
  def __repr__(self):
27279 
    L = ['%s=%r' % (key, value)
27280 
      for key, value in self.__dict__.iteritems()]
27281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27282 
 
27283 
  def __eq__(self, other):
27284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27285 
 
27286 
  def __ne__(self, other):
27287 
    return not (self == other)
5553 rajveer 27288 
 
27289 
class getReceivePendingOrders_args:
27290 
  """
27291 
  Attributes:
27292 
   - storeId
27293 
  """
27294 
 
27295 
  thrift_spec = (
27296 
    None, # 0
27297 
    (1, TType.I64, 'storeId', None, None, ), # 1
27298 
  )
27299 
 
27300 
  def __init__(self, storeId=None,):
27301 
    self.storeId = storeId
27302 
 
27303 
  def read(self, iprot):
27304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27306 
      return
27307 
    iprot.readStructBegin()
27308 
    while True:
27309 
      (fname, ftype, fid) = iprot.readFieldBegin()
27310 
      if ftype == TType.STOP:
27311 
        break
27312 
      if fid == 1:
27313 
        if ftype == TType.I64:
27314 
          self.storeId = iprot.readI64();
27315 
        else:
27316 
          iprot.skip(ftype)
27317 
      else:
27318 
        iprot.skip(ftype)
27319 
      iprot.readFieldEnd()
27320 
    iprot.readStructEnd()
27321 
 
27322 
  def write(self, oprot):
27323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27325 
      return
27326 
    oprot.writeStructBegin('getReceivePendingOrders_args')
27327 
    if self.storeId is not None:
27328 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27329 
      oprot.writeI64(self.storeId)
27330 
      oprot.writeFieldEnd()
27331 
    oprot.writeFieldStop()
27332 
    oprot.writeStructEnd()
27333 
 
27334 
  def validate(self):
27335 
    return
27336 
 
27337 
 
27338 
  def __repr__(self):
27339 
    L = ['%s=%r' % (key, value)
27340 
      for key, value in self.__dict__.iteritems()]
27341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27342 
 
27343 
  def __eq__(self, other):
27344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27345 
 
27346 
  def __ne__(self, other):
27347 
    return not (self == other)
27348 
 
27349 
class getReceivePendingOrders_result:
27350 
  """
27351 
  Attributes:
27352 
   - success
27353 
  """
27354 
 
27355 
  thrift_spec = (
27356 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27357 
  )
27358 
 
27359 
  def __init__(self, success=None,):
27360 
    self.success = success
27361 
 
27362 
  def read(self, iprot):
27363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27365 
      return
27366 
    iprot.readStructBegin()
27367 
    while True:
27368 
      (fname, ftype, fid) = iprot.readFieldBegin()
27369 
      if ftype == TType.STOP:
27370 
        break
27371 
      if fid == 0:
27372 
        if ftype == TType.LIST:
27373 
          self.success = []
6188 rajveer 27374 
          (_etype638, _size635) = iprot.readListBegin()
27375 
          for _i639 in xrange(_size635):
27376 
            _elem640 = Order()
27377 
            _elem640.read(iprot)
27378 
            self.success.append(_elem640)
5553 rajveer 27379 
          iprot.readListEnd()
27380 
        else:
27381 
          iprot.skip(ftype)
27382 
      else:
27383 
        iprot.skip(ftype)
27384 
      iprot.readFieldEnd()
27385 
    iprot.readStructEnd()
27386 
 
27387 
  def write(self, oprot):
27388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27390 
      return
27391 
    oprot.writeStructBegin('getReceivePendingOrders_result')
27392 
    if self.success is not None:
27393 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27394 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27395 
      for iter641 in self.success:
27396 
        iter641.write(oprot)
5553 rajveer 27397 
      oprot.writeListEnd()
27398 
      oprot.writeFieldEnd()
27399 
    oprot.writeFieldStop()
27400 
    oprot.writeStructEnd()
27401 
 
27402 
  def validate(self):
27403 
    return
27404 
 
27405 
 
27406 
  def __repr__(self):
27407 
    L = ['%s=%r' % (key, value)
27408 
      for key, value in self.__dict__.iteritems()]
27409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27410 
 
27411 
  def __eq__(self, other):
27412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27413 
 
27414 
  def __ne__(self, other):
27415 
    return not (self == other)
27416 
 
27417 
class getReceivedAtStoreOrders_args:
27418 
  """
27419 
  Attributes:
27420 
   - storeId
27421 
  """
27422 
 
27423 
  thrift_spec = (
27424 
    None, # 0
27425 
    (1, TType.I64, 'storeId', None, None, ), # 1
27426 
  )
27427 
 
27428 
  def __init__(self, storeId=None,):
27429 
    self.storeId = storeId
27430 
 
27431 
  def read(self, iprot):
27432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27434 
      return
27435 
    iprot.readStructBegin()
27436 
    while True:
27437 
      (fname, ftype, fid) = iprot.readFieldBegin()
27438 
      if ftype == TType.STOP:
27439 
        break
27440 
      if fid == 1:
27441 
        if ftype == TType.I64:
27442 
          self.storeId = iprot.readI64();
27443 
        else:
27444 
          iprot.skip(ftype)
27445 
      else:
27446 
        iprot.skip(ftype)
27447 
      iprot.readFieldEnd()
27448 
    iprot.readStructEnd()
27449 
 
27450 
  def write(self, oprot):
27451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27453 
      return
27454 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
27455 
    if self.storeId is not None:
27456 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27457 
      oprot.writeI64(self.storeId)
27458 
      oprot.writeFieldEnd()
27459 
    oprot.writeFieldStop()
27460 
    oprot.writeStructEnd()
27461 
 
27462 
  def validate(self):
27463 
    return
27464 
 
27465 
 
27466 
  def __repr__(self):
27467 
    L = ['%s=%r' % (key, value)
27468 
      for key, value in self.__dict__.iteritems()]
27469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27470 
 
27471 
  def __eq__(self, other):
27472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27473 
 
27474 
  def __ne__(self, other):
27475 
    return not (self == other)
27476 
 
27477 
class getReceivedAtStoreOrders_result:
27478 
  """
27479 
  Attributes:
27480 
   - success
27481 
  """
27482 
 
27483 
  thrift_spec = (
27484 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27485 
  )
27486 
 
27487 
  def __init__(self, success=None,):
27488 
    self.success = success
27489 
 
27490 
  def read(self, iprot):
27491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27493 
      return
27494 
    iprot.readStructBegin()
27495 
    while True:
27496 
      (fname, ftype, fid) = iprot.readFieldBegin()
27497 
      if ftype == TType.STOP:
27498 
        break
27499 
      if fid == 0:
27500 
        if ftype == TType.LIST:
27501 
          self.success = []
6188 rajveer 27502 
          (_etype645, _size642) = iprot.readListBegin()
27503 
          for _i646 in xrange(_size642):
27504 
            _elem647 = Order()
27505 
            _elem647.read(iprot)
27506 
            self.success.append(_elem647)
5553 rajveer 27507 
          iprot.readListEnd()
27508 
        else:
27509 
          iprot.skip(ftype)
27510 
      else:
27511 
        iprot.skip(ftype)
27512 
      iprot.readFieldEnd()
27513 
    iprot.readStructEnd()
27514 
 
27515 
  def write(self, oprot):
27516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27518 
      return
27519 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
27520 
    if self.success is not None:
27521 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27522 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27523 
      for iter648 in self.success:
27524 
        iter648.write(oprot)
5553 rajveer 27525 
      oprot.writeListEnd()
27526 
      oprot.writeFieldEnd()
27527 
    oprot.writeFieldStop()
27528 
    oprot.writeStructEnd()
27529 
 
27530 
  def validate(self):
27531 
    return
27532 
 
27533 
 
27534 
  def __repr__(self):
27535 
    L = ['%s=%r' % (key, value)
27536 
      for key, value in self.__dict__.iteritems()]
27537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27538 
 
27539 
  def __eq__(self, other):
27540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27541 
 
27542 
  def __ne__(self, other):
27543 
    return not (self == other)
5593 mandeep.dh 27544 
 
5713 rajveer 27545 
class getOrdersCollectionAtStore_args:
27546 
  """
27547 
  Attributes:
27548 
   - storeId
27549 
   - fromDate
27550 
   - toDate
27551 
   - onlyCod
27552 
  """
27553 
 
27554 
  thrift_spec = (
27555 
    None, # 0
27556 
    (1, TType.I64, 'storeId', None, None, ), # 1
27557 
    (2, TType.I64, 'fromDate', None, None, ), # 2
27558 
    (3, TType.I64, 'toDate', None, None, ), # 3
27559 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
27560 
  )
27561 
 
27562 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
27563 
    self.storeId = storeId
27564 
    self.fromDate = fromDate
27565 
    self.toDate = toDate
27566 
    self.onlyCod = onlyCod
27567 
 
27568 
  def read(self, iprot):
27569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27571 
      return
27572 
    iprot.readStructBegin()
27573 
    while True:
27574 
      (fname, ftype, fid) = iprot.readFieldBegin()
27575 
      if ftype == TType.STOP:
27576 
        break
27577 
      if fid == 1:
27578 
        if ftype == TType.I64:
27579 
          self.storeId = iprot.readI64();
27580 
        else:
27581 
          iprot.skip(ftype)
27582 
      elif fid == 2:
27583 
        if ftype == TType.I64:
27584 
          self.fromDate = iprot.readI64();
27585 
        else:
27586 
          iprot.skip(ftype)
27587 
      elif fid == 3:
27588 
        if ftype == TType.I64:
27589 
          self.toDate = iprot.readI64();
27590 
        else:
27591 
          iprot.skip(ftype)
27592 
      elif fid == 4:
27593 
        if ftype == TType.BOOL:
27594 
          self.onlyCod = iprot.readBool();
27595 
        else:
27596 
          iprot.skip(ftype)
27597 
      else:
27598 
        iprot.skip(ftype)
27599 
      iprot.readFieldEnd()
27600 
    iprot.readStructEnd()
27601 
 
27602 
  def write(self, oprot):
27603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27605 
      return
27606 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
27607 
    if self.storeId is not None:
27608 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27609 
      oprot.writeI64(self.storeId)
27610 
      oprot.writeFieldEnd()
27611 
    if self.fromDate is not None:
27612 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
27613 
      oprot.writeI64(self.fromDate)
27614 
      oprot.writeFieldEnd()
27615 
    if self.toDate is not None:
27616 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
27617 
      oprot.writeI64(self.toDate)
27618 
      oprot.writeFieldEnd()
27619 
    if self.onlyCod is not None:
27620 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
27621 
      oprot.writeBool(self.onlyCod)
27622 
      oprot.writeFieldEnd()
27623 
    oprot.writeFieldStop()
27624 
    oprot.writeStructEnd()
27625 
 
27626 
  def validate(self):
27627 
    return
27628 
 
27629 
 
27630 
  def __repr__(self):
27631 
    L = ['%s=%r' % (key, value)
27632 
      for key, value in self.__dict__.iteritems()]
27633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27634 
 
27635 
  def __eq__(self, other):
27636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27637 
 
27638 
  def __ne__(self, other):
27639 
    return not (self == other)
27640 
 
27641 
class getOrdersCollectionAtStore_result:
27642 
  """
27643 
  Attributes:
27644 
   - success
27645 
  """
27646 
 
27647 
  thrift_spec = (
27648 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27649 
  )
27650 
 
27651 
  def __init__(self, success=None,):
27652 
    self.success = success
27653 
 
27654 
  def read(self, iprot):
27655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27657 
      return
27658 
    iprot.readStructBegin()
27659 
    while True:
27660 
      (fname, ftype, fid) = iprot.readFieldBegin()
27661 
      if ftype == TType.STOP:
27662 
        break
27663 
      if fid == 0:
27664 
        if ftype == TType.LIST:
27665 
          self.success = []
6188 rajveer 27666 
          (_etype652, _size649) = iprot.readListBegin()
27667 
          for _i653 in xrange(_size649):
27668 
            _elem654 = Order()
27669 
            _elem654.read(iprot)
27670 
            self.success.append(_elem654)
5713 rajveer 27671 
          iprot.readListEnd()
27672 
        else:
27673 
          iprot.skip(ftype)
27674 
      else:
27675 
        iprot.skip(ftype)
27676 
      iprot.readFieldEnd()
27677 
    iprot.readStructEnd()
27678 
 
27679 
  def write(self, oprot):
27680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27682 
      return
27683 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
27684 
    if self.success is not None:
27685 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27686 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27687 
      for iter655 in self.success:
27688 
        iter655.write(oprot)
5713 rajveer 27689 
      oprot.writeListEnd()
27690 
      oprot.writeFieldEnd()
27691 
    oprot.writeFieldStop()
27692 
    oprot.writeStructEnd()
27693 
 
27694 
  def validate(self):
27695 
    return
27696 
 
27697 
 
27698 
  def __repr__(self):
27699 
    L = ['%s=%r' % (key, value)
27700 
      for key, value in self.__dict__.iteritems()]
27701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27702 
 
27703 
  def __eq__(self, other):
27704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27705 
 
27706 
  def __ne__(self, other):
27707 
    return not (self == other)
27708 
 
5833 rajveer 27709 
class getOrderAttributeValue_args:
27710 
  """
27711 
  Attributes:
27712 
   - orderId
27713 
   - attributeName
27714 
  """
27715 
 
27716 
  thrift_spec = None
27717 
  def __init__(self, orderId=None, attributeName=None,):
27718 
    self.orderId = orderId
27719 
    self.attributeName = attributeName
27720 
 
27721 
  def read(self, iprot):
27722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27724 
      return
27725 
    iprot.readStructBegin()
27726 
    while True:
27727 
      (fname, ftype, fid) = iprot.readFieldBegin()
27728 
      if ftype == TType.STOP:
27729 
        break
27730 
      if fid == 1:
27731 
        if ftype == TType.I64:
27732 
          self.orderId = iprot.readI64();
27733 
        else:
27734 
          iprot.skip(ftype)
27735 
      elif fid == -1:
27736 
        if ftype == TType.STRING:
27737 
          self.attributeName = iprot.readString();
27738 
        else:
27739 
          iprot.skip(ftype)
27740 
      else:
27741 
        iprot.skip(ftype)
27742 
      iprot.readFieldEnd()
27743 
    iprot.readStructEnd()
27744 
 
27745 
  def write(self, oprot):
27746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27748 
      return
27749 
    oprot.writeStructBegin('getOrderAttributeValue_args')
27750 
    if self.attributeName is not None:
27751 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
27752 
      oprot.writeString(self.attributeName)
27753 
      oprot.writeFieldEnd()
27754 
    if self.orderId is not None:
27755 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27756 
      oprot.writeI64(self.orderId)
27757 
      oprot.writeFieldEnd()
27758 
    oprot.writeFieldStop()
27759 
    oprot.writeStructEnd()
27760 
 
27761 
  def validate(self):
27762 
    return
27763 
 
27764 
 
27765 
  def __repr__(self):
27766 
    L = ['%s=%r' % (key, value)
27767 
      for key, value in self.__dict__.iteritems()]
27768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27769 
 
27770 
  def __eq__(self, other):
27771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27772 
 
27773 
  def __ne__(self, other):
27774 
    return not (self == other)
27775 
 
27776 
class getOrderAttributeValue_result:
27777 
  """
27778 
  Attributes:
27779 
   - success
27780 
  """
27781 
 
27782 
  thrift_spec = (
27783 
    (0, TType.STRING, 'success', None, None, ), # 0
27784 
  )
27785 
 
27786 
  def __init__(self, success=None,):
27787 
    self.success = success
27788 
 
27789 
  def read(self, iprot):
27790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27792 
      return
27793 
    iprot.readStructBegin()
27794 
    while True:
27795 
      (fname, ftype, fid) = iprot.readFieldBegin()
27796 
      if ftype == TType.STOP:
27797 
        break
27798 
      if fid == 0:
27799 
        if ftype == TType.STRING:
27800 
          self.success = iprot.readString();
27801 
        else:
27802 
          iprot.skip(ftype)
27803 
      else:
27804 
        iprot.skip(ftype)
27805 
      iprot.readFieldEnd()
27806 
    iprot.readStructEnd()
27807 
 
27808 
  def write(self, oprot):
27809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27811 
      return
27812 
    oprot.writeStructBegin('getOrderAttributeValue_result')
27813 
    if self.success is not None:
27814 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27815 
      oprot.writeString(self.success)
27816 
      oprot.writeFieldEnd()
27817 
    oprot.writeFieldStop()
27818 
    oprot.writeStructEnd()
27819 
 
27820 
  def validate(self):
27821 
    return
27822 
 
27823 
 
27824 
  def __repr__(self):
27825 
    L = ['%s=%r' % (key, value)
27826 
      for key, value in self.__dict__.iteritems()]
27827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27828 
 
27829 
  def __eq__(self, other):
27830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27831 
 
27832 
  def __ne__(self, other):
27833 
    return not (self == other)
27834 
 
6019 rajveer 27835 
class changeJacketNumber_args:
27836 
  """
27837 
  Attributes:
27838 
   - orderId
27839 
   - jacketNumber
27840 
  """
27841 
 
27842 
  thrift_spec = (
27843 
    None, # 0
27844 
    (1, TType.I64, 'orderId', None, None, ), # 1
27845 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27846 
  )
27847 
 
27848 
  def __init__(self, orderId=None, jacketNumber=None,):
27849 
    self.orderId = orderId
27850 
    self.jacketNumber = jacketNumber
27851 
 
27852 
  def read(self, iprot):
27853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27855 
      return
27856 
    iprot.readStructBegin()
27857 
    while True:
27858 
      (fname, ftype, fid) = iprot.readFieldBegin()
27859 
      if ftype == TType.STOP:
27860 
        break
27861 
      if fid == 1:
27862 
        if ftype == TType.I64:
27863 
          self.orderId = iprot.readI64();
27864 
        else:
27865 
          iprot.skip(ftype)
27866 
      elif fid == 2:
27867 
        if ftype == TType.I64:
27868 
          self.jacketNumber = iprot.readI64();
27869 
        else:
27870 
          iprot.skip(ftype)
27871 
      else:
27872 
        iprot.skip(ftype)
27873 
      iprot.readFieldEnd()
27874 
    iprot.readStructEnd()
27875 
 
27876 
  def write(self, oprot):
27877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27879 
      return
27880 
    oprot.writeStructBegin('changeJacketNumber_args')
27881 
    if self.orderId is not None:
27882 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27883 
      oprot.writeI64(self.orderId)
27884 
      oprot.writeFieldEnd()
27885 
    if self.jacketNumber is not None:
27886 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27887 
      oprot.writeI64(self.jacketNumber)
27888 
      oprot.writeFieldEnd()
27889 
    oprot.writeFieldStop()
27890 
    oprot.writeStructEnd()
27891 
 
27892 
  def validate(self):
27893 
    return
27894 
 
27895 
 
27896 
  def __repr__(self):
27897 
    L = ['%s=%r' % (key, value)
27898 
      for key, value in self.__dict__.iteritems()]
27899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27900 
 
27901 
  def __eq__(self, other):
27902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27903 
 
27904 
  def __ne__(self, other):
27905 
    return not (self == other)
27906 
 
27907 
class changeJacketNumber_result:
27908 
  """
27909 
  Attributes:
27910 
   - success
27911 
  """
27912 
 
27913 
  thrift_spec = (
27914 
    (0, TType.BOOL, 'success', None, None, ), # 0
27915 
  )
27916 
 
27917 
  def __init__(self, success=None,):
27918 
    self.success = success
27919 
 
27920 
  def read(self, iprot):
27921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27923 
      return
27924 
    iprot.readStructBegin()
27925 
    while True:
27926 
      (fname, ftype, fid) = iprot.readFieldBegin()
27927 
      if ftype == TType.STOP:
27928 
        break
27929 
      if fid == 0:
27930 
        if ftype == TType.BOOL:
27931 
          self.success = iprot.readBool();
27932 
        else:
27933 
          iprot.skip(ftype)
27934 
      else:
27935 
        iprot.skip(ftype)
27936 
      iprot.readFieldEnd()
27937 
    iprot.readStructEnd()
27938 
 
27939 
  def write(self, oprot):
27940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27942 
      return
27943 
    oprot.writeStructBegin('changeJacketNumber_result')
27944 
    if self.success is not None:
27945 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27946 
      oprot.writeBool(self.success)
27947 
      oprot.writeFieldEnd()
27948 
    oprot.writeFieldStop()
27949 
    oprot.writeStructEnd()
27950 
 
27951 
  def validate(self):
27952 
    return
27953 
 
27954 
 
27955 
  def __repr__(self):
27956 
    L = ['%s=%r' % (key, value)
27957 
      for key, value in self.__dict__.iteritems()]
27958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27959 
 
27960 
  def __eq__(self, other):
27961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27962 
 
27963 
  def __ne__(self, other):
27964 
    return not (self == other)
27965 
 
27966 
class markOrderAsRtoInTransit_args:
27967 
  """
27968 
  Attributes:
27969 
   - orderId
27970 
  """
27971 
 
27972 
  thrift_spec = (
27973 
    None, # 0
27974 
    (1, TType.I64, 'orderId', None, None, ), # 1
27975 
  )
27976 
 
27977 
  def __init__(self, orderId=None,):
27978 
    self.orderId = orderId
27979 
 
27980 
  def read(self, iprot):
27981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27983 
      return
27984 
    iprot.readStructBegin()
27985 
    while True:
27986 
      (fname, ftype, fid) = iprot.readFieldBegin()
27987 
      if ftype == TType.STOP:
27988 
        break
27989 
      if fid == 1:
27990 
        if ftype == TType.I64:
27991 
          self.orderId = iprot.readI64();
27992 
        else:
27993 
          iprot.skip(ftype)
27994 
      else:
27995 
        iprot.skip(ftype)
27996 
      iprot.readFieldEnd()
27997 
    iprot.readStructEnd()
27998 
 
27999 
  def write(self, oprot):
28000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28002 
      return
28003 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
28004 
    if self.orderId is not None:
28005 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
28006 
      oprot.writeI64(self.orderId)
28007 
      oprot.writeFieldEnd()
28008 
    oprot.writeFieldStop()
28009 
    oprot.writeStructEnd()
28010 
 
28011 
  def validate(self):
28012 
    return
28013 
 
28014 
 
28015 
  def __repr__(self):
28016 
    L = ['%s=%r' % (key, value)
28017 
      for key, value in self.__dict__.iteritems()]
28018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28019 
 
28020 
  def __eq__(self, other):
28021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28022 
 
28023 
  def __ne__(self, other):
28024 
    return not (self == other)
28025 
 
28026 
class markOrderAsRtoInTransit_result:
28027 
  """
28028 
  Attributes:
28029 
   - success
28030 
  """
28031 
 
28032 
  thrift_spec = (
28033 
    (0, TType.BOOL, 'success', None, None, ), # 0
28034 
  )
28035 
 
28036 
  def __init__(self, success=None,):
28037 
    self.success = success
28038 
 
28039 
  def read(self, iprot):
28040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28042 
      return
28043 
    iprot.readStructBegin()
28044 
    while True:
28045 
      (fname, ftype, fid) = iprot.readFieldBegin()
28046 
      if ftype == TType.STOP:
28047 
        break
28048 
      if fid == 0:
28049 
        if ftype == TType.BOOL:
28050 
          self.success = iprot.readBool();
28051 
        else:
28052 
          iprot.skip(ftype)
28053 
      else:
28054 
        iprot.skip(ftype)
28055 
      iprot.readFieldEnd()
28056 
    iprot.readStructEnd()
28057 
 
28058 
  def write(self, oprot):
28059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28061 
      return
28062 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
28063 
    if self.success is not None:
28064 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28065 
      oprot.writeBool(self.success)
28066 
      oprot.writeFieldEnd()
28067 
    oprot.writeFieldStop()
28068 
    oprot.writeStructEnd()
28069 
 
28070 
  def validate(self):
28071 
    return
28072 
 
28073 
 
28074 
  def __repr__(self):
28075 
    L = ['%s=%r' % (key, value)
28076 
      for key, value in self.__dict__.iteritems()]
28077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28078 
 
28079 
  def __eq__(self, other):
28080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28081 
 
28082 
  def __ne__(self, other):
28083 
    return not (self == other)
28084 
 
5593 mandeep.dh 28085 
class acceptOrderForItem_args:
28086 
  """
28087 
  Attributes:
28088 
   - itemId
28089 
   - quantity
28090 
   - fulfilmentWarehouseId
28091 
   - billingWarehouseId
28092 
  """
28093 
 
28094 
  thrift_spec = (
28095 
    None, # 0
28096 
    (1, TType.I64, 'itemId', None, None, ), # 1
28097 
    (2, TType.I64, 'quantity', None, None, ), # 2
28098 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
28099 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
28100 
  )
28101 
 
28102 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
28103 
    self.itemId = itemId
28104 
    self.quantity = quantity
28105 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
28106 
    self.billingWarehouseId = billingWarehouseId
28107 
 
28108 
  def read(self, iprot):
28109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28111 
      return
28112 
    iprot.readStructBegin()
28113 
    while True:
28114 
      (fname, ftype, fid) = iprot.readFieldBegin()
28115 
      if ftype == TType.STOP:
28116 
        break
28117 
      if fid == 1:
28118 
        if ftype == TType.I64:
28119 
          self.itemId = iprot.readI64();
28120 
        else:
28121 
          iprot.skip(ftype)
28122 
      elif fid == 2:
28123 
        if ftype == TType.I64:
28124 
          self.quantity = iprot.readI64();
28125 
        else:
28126 
          iprot.skip(ftype)
28127 
      elif fid == 3:
28128 
        if ftype == TType.I64:
28129 
          self.fulfilmentWarehouseId = iprot.readI64();
28130 
        else:
28131 
          iprot.skip(ftype)
28132 
      elif fid == 4:
28133 
        if ftype == TType.I64:
28134 
          self.billingWarehouseId = iprot.readI64();
28135 
        else:
28136 
          iprot.skip(ftype)
28137 
      else:
28138 
        iprot.skip(ftype)
28139 
      iprot.readFieldEnd()
28140 
    iprot.readStructEnd()
28141 
 
28142 
  def write(self, oprot):
28143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28145 
      return
28146 
    oprot.writeStructBegin('acceptOrderForItem_args')
28147 
    if self.itemId is not None:
28148 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
28149 
      oprot.writeI64(self.itemId)
28150 
      oprot.writeFieldEnd()
28151 
    if self.quantity is not None:
28152 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
28153 
      oprot.writeI64(self.quantity)
28154 
      oprot.writeFieldEnd()
28155 
    if self.fulfilmentWarehouseId is not None:
28156 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
28157 
      oprot.writeI64(self.fulfilmentWarehouseId)
28158 
      oprot.writeFieldEnd()
28159 
    if self.billingWarehouseId is not None:
28160 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
28161 
      oprot.writeI64(self.billingWarehouseId)
28162 
      oprot.writeFieldEnd()
28163 
    oprot.writeFieldStop()
28164 
    oprot.writeStructEnd()
28165 
 
28166 
  def validate(self):
28167 
    return
28168 
 
28169 
 
28170 
  def __repr__(self):
28171 
    L = ['%s=%r' % (key, value)
28172 
      for key, value in self.__dict__.iteritems()]
28173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28174 
 
28175 
  def __eq__(self, other):
28176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28177 
 
28178 
  def __ne__(self, other):
28179 
    return not (self == other)
28180 
 
28181 
class acceptOrderForItem_result:
28182 
 
28183 
  thrift_spec = (
28184 
  )
28185 
 
28186 
  def read(self, iprot):
28187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28189 
      return
28190 
    iprot.readStructBegin()
28191 
    while True:
28192 
      (fname, ftype, fid) = iprot.readFieldBegin()
28193 
      if ftype == TType.STOP:
28194 
        break
28195 
      else:
28196 
        iprot.skip(ftype)
28197 
      iprot.readFieldEnd()
28198 
    iprot.readStructEnd()
28199 
 
28200 
  def write(self, oprot):
28201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28203 
      return
28204 
    oprot.writeStructBegin('acceptOrderForItem_result')
28205 
    oprot.writeFieldStop()
28206 
    oprot.writeStructEnd()
28207 
 
28208 
  def validate(self):
28209 
    return
28210 
 
28211 
 
28212 
  def __repr__(self):
28213 
    L = ['%s=%r' % (key, value)
28214 
      for key, value in self.__dict__.iteritems()]
28215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28216 
 
28217 
  def __eq__(self, other):
28218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28219 
 
28220 
  def __ne__(self, other):
28221 
    return not (self == other)
6000 mandeep.dh 28222 
 
28223 
class createRechargeOrder_args:
28224 
  """
28225 
  Attributes:
28226 
   - rechargeOrder
28227 
  """
28228 
 
28229 
  thrift_spec = (
28230 
    None, # 0
28231 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
28232 
  )
28233 
 
28234 
  def __init__(self, rechargeOrder=None,):
28235 
    self.rechargeOrder = rechargeOrder
28236 
 
28237 
  def read(self, iprot):
28238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28240 
      return
28241 
    iprot.readStructBegin()
28242 
    while True:
28243 
      (fname, ftype, fid) = iprot.readFieldBegin()
28244 
      if ftype == TType.STOP:
28245 
        break
28246 
      if fid == 1:
28247 
        if ftype == TType.STRUCT:
28248 
          self.rechargeOrder = RechargeOrder()
28249 
          self.rechargeOrder.read(iprot)
28250 
        else:
28251 
          iprot.skip(ftype)
28252 
      else:
28253 
        iprot.skip(ftype)
28254 
      iprot.readFieldEnd()
28255 
    iprot.readStructEnd()
28256 
 
28257 
  def write(self, oprot):
28258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28260 
      return
28261 
    oprot.writeStructBegin('createRechargeOrder_args')
28262 
    if self.rechargeOrder is not None:
28263 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
28264 
      self.rechargeOrder.write(oprot)
28265 
      oprot.writeFieldEnd()
28266 
    oprot.writeFieldStop()
28267 
    oprot.writeStructEnd()
28268 
 
28269 
  def validate(self):
28270 
    return
28271 
 
28272 
 
28273 
  def __repr__(self):
28274 
    L = ['%s=%r' % (key, value)
28275 
      for key, value in self.__dict__.iteritems()]
28276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28277 
 
28278 
  def __eq__(self, other):
28279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28280 
 
28281 
  def __ne__(self, other):
28282 
    return not (self == other)
28283 
 
28284 
class createRechargeOrder_result:
28285 
  """
28286 
  Attributes:
28287 
   - success
28288 
   - ex
28289 
  """
28290 
 
28291 
  thrift_spec = (
28292 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28293 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28294 
  )
28295 
 
28296 
  def __init__(self, success=None, ex=None,):
28297 
    self.success = success
28298 
    self.ex = ex
28299 
 
28300 
  def read(self, iprot):
28301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28303 
      return
28304 
    iprot.readStructBegin()
28305 
    while True:
28306 
      (fname, ftype, fid) = iprot.readFieldBegin()
28307 
      if ftype == TType.STOP:
28308 
        break
28309 
      if fid == 0:
28310 
        if ftype == TType.STRUCT:
28311 
          self.success = RechargeOrder()
28312 
          self.success.read(iprot)
28313 
        else:
28314 
          iprot.skip(ftype)
28315 
      elif fid == 1:
28316 
        if ftype == TType.STRUCT:
28317 
          self.ex = TransactionServiceException()
28318 
          self.ex.read(iprot)
28319 
        else:
28320 
          iprot.skip(ftype)
28321 
      else:
28322 
        iprot.skip(ftype)
28323 
      iprot.readFieldEnd()
28324 
    iprot.readStructEnd()
28325 
 
28326 
  def write(self, oprot):
28327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28329 
      return
28330 
    oprot.writeStructBegin('createRechargeOrder_result')
28331 
    if self.success is not None:
28332 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28333 
      self.success.write(oprot)
28334 
      oprot.writeFieldEnd()
28335 
    if self.ex is not None:
28336 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28337 
      self.ex.write(oprot)
28338 
      oprot.writeFieldEnd()
28339 
    oprot.writeFieldStop()
28340 
    oprot.writeStructEnd()
28341 
 
28342 
  def validate(self):
28343 
    return
28344 
 
28345 
 
28346 
  def __repr__(self):
28347 
    L = ['%s=%r' % (key, value)
28348 
      for key, value in self.__dict__.iteritems()]
28349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28350 
 
28351 
  def __eq__(self, other):
28352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28353 
 
28354 
  def __ne__(self, other):
28355 
    return not (self == other)
28356 
 
6031 rajveer 28357 
class getRechargeOrder_args:
28358 
  """
28359 
  Attributes:
28360 
   - rechargeRrderId
28361 
  """
28362 
 
28363 
  thrift_spec = (
28364 
    None, # 0
28365 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
28366 
  )
28367 
 
28368 
  def __init__(self, rechargeRrderId=None,):
28369 
    self.rechargeRrderId = rechargeRrderId
28370 
 
28371 
  def read(self, iprot):
28372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28374 
      return
28375 
    iprot.readStructBegin()
28376 
    while True:
28377 
      (fname, ftype, fid) = iprot.readFieldBegin()
28378 
      if ftype == TType.STOP:
28379 
        break
28380 
      if fid == 1:
28381 
        if ftype == TType.I64:
28382 
          self.rechargeRrderId = iprot.readI64();
28383 
        else:
28384 
          iprot.skip(ftype)
28385 
      else:
28386 
        iprot.skip(ftype)
28387 
      iprot.readFieldEnd()
28388 
    iprot.readStructEnd()
28389 
 
28390 
  def write(self, oprot):
28391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28393 
      return
28394 
    oprot.writeStructBegin('getRechargeOrder_args')
28395 
    if self.rechargeRrderId is not None:
28396 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
28397 
      oprot.writeI64(self.rechargeRrderId)
28398 
      oprot.writeFieldEnd()
28399 
    oprot.writeFieldStop()
28400 
    oprot.writeStructEnd()
28401 
 
28402 
  def validate(self):
28403 
    return
28404 
 
28405 
 
28406 
  def __repr__(self):
28407 
    L = ['%s=%r' % (key, value)
28408 
      for key, value in self.__dict__.iteritems()]
28409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28410 
 
28411 
  def __eq__(self, other):
28412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28413 
 
28414 
  def __ne__(self, other):
28415 
    return not (self == other)
28416 
 
28417 
class getRechargeOrder_result:
28418 
  """
28419 
  Attributes:
28420 
   - success
28421 
   - ex
28422 
  """
28423 
 
28424 
  thrift_spec = (
28425 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28427 
  )
28428 
 
28429 
  def __init__(self, success=None, ex=None,):
28430 
    self.success = success
28431 
    self.ex = ex
28432 
 
28433 
  def read(self, iprot):
28434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28436 
      return
28437 
    iprot.readStructBegin()
28438 
    while True:
28439 
      (fname, ftype, fid) = iprot.readFieldBegin()
28440 
      if ftype == TType.STOP:
28441 
        break
28442 
      if fid == 0:
28443 
        if ftype == TType.STRUCT:
28444 
          self.success = RechargeOrder()
28445 
          self.success.read(iprot)
28446 
        else:
28447 
          iprot.skip(ftype)
28448 
      elif fid == 1:
28449 
        if ftype == TType.STRUCT:
28450 
          self.ex = TransactionServiceException()
28451 
          self.ex.read(iprot)
28452 
        else:
28453 
          iprot.skip(ftype)
28454 
      else:
28455 
        iprot.skip(ftype)
28456 
      iprot.readFieldEnd()
28457 
    iprot.readStructEnd()
28458 
 
28459 
  def write(self, oprot):
28460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28462 
      return
28463 
    oprot.writeStructBegin('getRechargeOrder_result')
28464 
    if self.success is not None:
28465 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28466 
      self.success.write(oprot)
28467 
      oprot.writeFieldEnd()
28468 
    if self.ex is not None:
28469 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28470 
      self.ex.write(oprot)
28471 
      oprot.writeFieldEnd()
28472 
    oprot.writeFieldStop()
28473 
    oprot.writeStructEnd()
28474 
 
28475 
  def validate(self):
28476 
    return
28477 
 
28478 
 
28479 
  def __repr__(self):
28480 
    L = ['%s=%r' % (key, value)
28481 
      for key, value in self.__dict__.iteritems()]
28482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28483 
 
28484 
  def __eq__(self, other):
28485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28486 
 
28487 
  def __ne__(self, other):
28488 
    return not (self == other)
28489 
 
28490 
class getRechargeOrders_args:
28491 
  """
28492 
  Attributes:
28493 
   - userId
28494 
  """
28495 
 
28496 
  thrift_spec = (
28497 
    None, # 0
28498 
    (1, TType.I64, 'userId', None, None, ), # 1
28499 
  )
28500 
 
28501 
  def __init__(self, userId=None,):
28502 
    self.userId = userId
28503 
 
28504 
  def read(self, iprot):
28505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28507 
      return
28508 
    iprot.readStructBegin()
28509 
    while True:
28510 
      (fname, ftype, fid) = iprot.readFieldBegin()
28511 
      if ftype == TType.STOP:
28512 
        break
28513 
      if fid == 1:
28514 
        if ftype == TType.I64:
28515 
          self.userId = iprot.readI64();
28516 
        else:
28517 
          iprot.skip(ftype)
28518 
      else:
28519 
        iprot.skip(ftype)
28520 
      iprot.readFieldEnd()
28521 
    iprot.readStructEnd()
28522 
 
28523 
  def write(self, oprot):
28524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28526 
      return
28527 
    oprot.writeStructBegin('getRechargeOrders_args')
28528 
    if self.userId is not None:
28529 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28530 
      oprot.writeI64(self.userId)
28531 
      oprot.writeFieldEnd()
28532 
    oprot.writeFieldStop()
28533 
    oprot.writeStructEnd()
28534 
 
28535 
  def validate(self):
28536 
    return
28537 
 
28538 
 
28539 
  def __repr__(self):
28540 
    L = ['%s=%r' % (key, value)
28541 
      for key, value in self.__dict__.iteritems()]
28542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28543 
 
28544 
  def __eq__(self, other):
28545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28546 
 
28547 
  def __ne__(self, other):
28548 
    return not (self == other)
28549 
 
28550 
class getRechargeOrders_result:
28551 
  """
28552 
  Attributes:
28553 
   - success
28554 
  """
28555 
 
28556 
  thrift_spec = (
28557 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28558 
  )
28559 
 
28560 
  def __init__(self, success=None,):
28561 
    self.success = success
28562 
 
28563 
  def read(self, iprot):
28564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28566 
      return
28567 
    iprot.readStructBegin()
28568 
    while True:
28569 
      (fname, ftype, fid) = iprot.readFieldBegin()
28570 
      if ftype == TType.STOP:
28571 
        break
28572 
      if fid == 0:
28573 
        if ftype == TType.LIST:
28574 
          self.success = []
6188 rajveer 28575 
          (_etype659, _size656) = iprot.readListBegin()
28576 
          for _i660 in xrange(_size656):
28577 
            _elem661 = RechargeOrder()
28578 
            _elem661.read(iprot)
28579 
            self.success.append(_elem661)
6031 rajveer 28580 
          iprot.readListEnd()
28581 
        else:
28582 
          iprot.skip(ftype)
28583 
      else:
28584 
        iprot.skip(ftype)
28585 
      iprot.readFieldEnd()
28586 
    iprot.readStructEnd()
28587 
 
28588 
  def write(self, oprot):
28589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28591 
      return
28592 
    oprot.writeStructBegin('getRechargeOrders_result')
28593 
    if self.success is not None:
28594 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28595 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28596 
      for iter662 in self.success:
28597 
        iter662.write(oprot)
6031 rajveer 28598 
      oprot.writeListEnd()
28599 
      oprot.writeFieldEnd()
28600 
    oprot.writeFieldStop()
28601 
    oprot.writeStructEnd()
28602 
 
28603 
  def validate(self):
28604 
    return
28605 
 
28606 
 
28607 
  def __repr__(self):
28608 
    L = ['%s=%r' % (key, value)
28609 
      for key, value in self.__dict__.iteritems()]
28610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28611 
 
28612 
  def __eq__(self, other):
28613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28614 
 
28615 
  def __ne__(self, other):
28616 
    return not (self == other)
28617 
 
6000 mandeep.dh 28618 
class updateRechargeOrderStatus_args:
28619 
  """
28620 
  Attributes:
28621 
   - rechargeOrderId
28622 
   - rechargeOrderStatus
28623 
  """
28624 
 
28625 
  thrift_spec = (
28626 
    None, # 0
28627 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
28628 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
28629 
  )
28630 
 
28631 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
28632 
    self.rechargeOrderId = rechargeOrderId
28633 
    self.rechargeOrderStatus = rechargeOrderStatus
28634 
 
28635 
  def read(self, iprot):
28636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28638 
      return
28639 
    iprot.readStructBegin()
28640 
    while True:
28641 
      (fname, ftype, fid) = iprot.readFieldBegin()
28642 
      if ftype == TType.STOP:
28643 
        break
28644 
      if fid == 1:
28645 
        if ftype == TType.I64:
28646 
          self.rechargeOrderId = iprot.readI64();
28647 
        else:
28648 
          iprot.skip(ftype)
28649 
      elif fid == 2:
28650 
        if ftype == TType.I32:
28651 
          self.rechargeOrderStatus = iprot.readI32();
28652 
        else:
28653 
          iprot.skip(ftype)
28654 
      else:
28655 
        iprot.skip(ftype)
28656 
      iprot.readFieldEnd()
28657 
    iprot.readStructEnd()
28658 
 
28659 
  def write(self, oprot):
28660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28662 
      return
28663 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
28664 
    if self.rechargeOrderId is not None:
28665 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28666 
      oprot.writeI64(self.rechargeOrderId)
28667 
      oprot.writeFieldEnd()
28668 
    if self.rechargeOrderStatus is not None:
28669 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
28670 
      oprot.writeI32(self.rechargeOrderStatus)
28671 
      oprot.writeFieldEnd()
28672 
    oprot.writeFieldStop()
28673 
    oprot.writeStructEnd()
28674 
 
28675 
  def validate(self):
28676 
    return
28677 
 
28678 
 
28679 
  def __repr__(self):
28680 
    L = ['%s=%r' % (key, value)
28681 
      for key, value in self.__dict__.iteritems()]
28682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28683 
 
28684 
  def __eq__(self, other):
28685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28686 
 
28687 
  def __ne__(self, other):
28688 
    return not (self == other)
28689 
 
28690 
class updateRechargeOrderStatus_result:
28691 
  """
28692 
  Attributes:
6031 rajveer 28693 
   - success
6000 mandeep.dh 28694 
   - ex
28695 
  """
28696 
 
28697 
  thrift_spec = (
6031 rajveer 28698 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28699 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28700 
  )
28701 
 
6031 rajveer 28702 
  def __init__(self, success=None, ex=None,):
28703 
    self.success = success
6000 mandeep.dh 28704 
    self.ex = ex
28705 
 
28706 
  def read(self, iprot):
28707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28709 
      return
28710 
    iprot.readStructBegin()
28711 
    while True:
28712 
      (fname, ftype, fid) = iprot.readFieldBegin()
28713 
      if ftype == TType.STOP:
28714 
        break
6031 rajveer 28715 
      if fid == 0:
28716 
        if ftype == TType.BOOL:
28717 
          self.success = iprot.readBool();
28718 
        else:
28719 
          iprot.skip(ftype)
28720 
      elif fid == 1:
6000 mandeep.dh 28721 
        if ftype == TType.STRUCT:
28722 
          self.ex = TransactionServiceException()
28723 
          self.ex.read(iprot)
28724 
        else:
28725 
          iprot.skip(ftype)
28726 
      else:
28727 
        iprot.skip(ftype)
28728 
      iprot.readFieldEnd()
28729 
    iprot.readStructEnd()
28730 
 
28731 
  def write(self, oprot):
28732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28734 
      return
28735 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 28736 
    if self.success is not None:
28737 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28738 
      oprot.writeBool(self.success)
28739 
      oprot.writeFieldEnd()
6000 mandeep.dh 28740 
    if self.ex is not None:
28741 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28742 
      self.ex.write(oprot)
28743 
      oprot.writeFieldEnd()
28744 
    oprot.writeFieldStop()
28745 
    oprot.writeStructEnd()
28746 
 
28747 
  def validate(self):
28748 
    return
28749 
 
28750 
 
28751 
  def __repr__(self):
28752 
    L = ['%s=%r' % (key, value)
28753 
      for key, value in self.__dict__.iteritems()]
28754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28755 
 
28756 
  def __eq__(self, other):
28757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28758 
 
28759 
  def __ne__(self, other):
28760 
    return not (self == other)
28761 
 
28762 
class activateRechargeTxn_args:
28763 
  """
28764 
  Attributes:
6031 rajveer 28765 
   - rechargeOrderId
6000 mandeep.dh 28766 
  """
28767 
 
28768 
  thrift_spec = (
28769 
    None, # 0
6031 rajveer 28770 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 28771 
  )
28772 
 
6031 rajveer 28773 
  def __init__(self, rechargeOrderId=None,):
28774 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 28775 
 
28776 
  def read(self, iprot):
28777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28779 
      return
28780 
    iprot.readStructBegin()
28781 
    while True:
28782 
      (fname, ftype, fid) = iprot.readFieldBegin()
28783 
      if ftype == TType.STOP:
28784 
        break
28785 
      if fid == 1:
6031 rajveer 28786 
        if ftype == TType.I64:
28787 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 28788 
        else:
28789 
          iprot.skip(ftype)
28790 
      else:
28791 
        iprot.skip(ftype)
28792 
      iprot.readFieldEnd()
28793 
    iprot.readStructEnd()
28794 
 
28795 
  def write(self, oprot):
28796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28798 
      return
28799 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 28800 
    if self.rechargeOrderId is not None:
28801 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28802 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 28803 
      oprot.writeFieldEnd()
28804 
    oprot.writeFieldStop()
28805 
    oprot.writeStructEnd()
28806 
 
28807 
  def validate(self):
28808 
    return
28809 
 
28810 
 
28811 
  def __repr__(self):
28812 
    L = ['%s=%r' % (key, value)
28813 
      for key, value in self.__dict__.iteritems()]
28814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28815 
 
28816 
  def __eq__(self, other):
28817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28818 
 
28819 
  def __ne__(self, other):
28820 
    return not (self == other)
28821 
 
28822 
class activateRechargeTxn_result:
28823 
  """
28824 
  Attributes:
28825 
   - success
28826 
   - ex
28827 
  """
28828 
 
28829 
  thrift_spec = (
6031 rajveer 28830 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28831 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28832 
  )
28833 
 
28834 
  def __init__(self, success=None, ex=None,):
28835 
    self.success = success
28836 
    self.ex = ex
28837 
 
28838 
  def read(self, iprot):
28839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28841 
      return
28842 
    iprot.readStructBegin()
28843 
    while True:
28844 
      (fname, ftype, fid) = iprot.readFieldBegin()
28845 
      if ftype == TType.STOP:
28846 
        break
28847 
      if fid == 0:
6031 rajveer 28848 
        if ftype == TType.BOOL:
28849 
          self.success = iprot.readBool();
6000 mandeep.dh 28850 
        else:
28851 
          iprot.skip(ftype)
28852 
      elif fid == 1:
28853 
        if ftype == TType.STRUCT:
28854 
          self.ex = TransactionServiceException()
28855 
          self.ex.read(iprot)
28856 
        else:
28857 
          iprot.skip(ftype)
28858 
      else:
28859 
        iprot.skip(ftype)
28860 
      iprot.readFieldEnd()
28861 
    iprot.readStructEnd()
28862 
 
28863 
  def write(self, oprot):
28864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28866 
      return
28867 
    oprot.writeStructBegin('activateRechargeTxn_result')
28868 
    if self.success is not None:
6031 rajveer 28869 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28870 
      oprot.writeBool(self.success)
6000 mandeep.dh 28871 
      oprot.writeFieldEnd()
28872 
    if self.ex is not None:
28873 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28874 
      self.ex.write(oprot)
28875 
      oprot.writeFieldEnd()
28876 
    oprot.writeFieldStop()
28877 
    oprot.writeStructEnd()
28878 
 
28879 
  def validate(self):
28880 
    return
28881 
 
28882 
 
28883 
  def __repr__(self):
28884 
    L = ['%s=%r' % (key, value)
28885 
      for key, value in self.__dict__.iteritems()]
28886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28887 
 
28888 
  def __eq__(self, other):
28889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28890 
 
28891 
  def __ne__(self, other):
28892 
    return not (self == other)
28893 
 
6031 rajveer 28894 
class getUserWallet_args:
6000 mandeep.dh 28895 
  """
28896 
  Attributes:
6031 rajveer 28897 
   - userId
6000 mandeep.dh 28898 
  """
28899 
 
28900 
  thrift_spec = (
28901 
    None, # 0
6031 rajveer 28902 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28903 
  )
28904 
 
6031 rajveer 28905 
  def __init__(self, userId=None,):
28906 
    self.userId = userId
6000 mandeep.dh 28907 
 
28908 
  def read(self, iprot):
28909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28911 
      return
28912 
    iprot.readStructBegin()
28913 
    while True:
28914 
      (fname, ftype, fid) = iprot.readFieldBegin()
28915 
      if ftype == TType.STOP:
28916 
        break
28917 
      if fid == 1:
28918 
        if ftype == TType.I64:
6031 rajveer 28919 
          self.userId = iprot.readI64();
6000 mandeep.dh 28920 
        else:
28921 
          iprot.skip(ftype)
28922 
      else:
28923 
        iprot.skip(ftype)
28924 
      iprot.readFieldEnd()
28925 
    iprot.readStructEnd()
28926 
 
28927 
  def write(self, oprot):
28928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28930 
      return
6031 rajveer 28931 
    oprot.writeStructBegin('getUserWallet_args')
28932 
    if self.userId is not None:
28933 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28934 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28935 
      oprot.writeFieldEnd()
28936 
    oprot.writeFieldStop()
28937 
    oprot.writeStructEnd()
28938 
 
28939 
  def validate(self):
28940 
    return
28941 
 
28942 
 
28943 
  def __repr__(self):
28944 
    L = ['%s=%r' % (key, value)
28945 
      for key, value in self.__dict__.iteritems()]
28946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28947 
 
28948 
  def __eq__(self, other):
28949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28950 
 
28951 
  def __ne__(self, other):
28952 
    return not (self == other)
28953 
 
6031 rajveer 28954 
class getUserWallet_result:
6000 mandeep.dh 28955 
  """
28956 
  Attributes:
28957 
   - success
28958 
  """
28959 
 
28960 
  thrift_spec = (
6031 rajveer 28961 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28962 
  )
28963 
 
28964 
  def __init__(self, success=None,):
28965 
    self.success = success
28966 
 
28967 
  def read(self, iprot):
28968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28970 
      return
28971 
    iprot.readStructBegin()
28972 
    while True:
28973 
      (fname, ftype, fid) = iprot.readFieldBegin()
28974 
      if ftype == TType.STOP:
28975 
        break
28976 
      if fid == 0:
6031 rajveer 28977 
        if ftype == TType.STRUCT:
28978 
          self.success = UserWallet()
28979 
          self.success.read(iprot)
6000 mandeep.dh 28980 
        else:
28981 
          iprot.skip(ftype)
28982 
      else:
28983 
        iprot.skip(ftype)
28984 
      iprot.readFieldEnd()
28985 
    iprot.readStructEnd()
28986 
 
28987 
  def write(self, oprot):
28988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28990 
      return
6031 rajveer 28991 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28992 
    if self.success is not None:
6031 rajveer 28993 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28994 
      self.success.write(oprot)
6000 mandeep.dh 28995 
      oprot.writeFieldEnd()
28996 
    oprot.writeFieldStop()
28997 
    oprot.writeStructEnd()
28998 
 
28999 
  def validate(self):
29000 
    return
29001 
 
29002 
 
29003 
  def __repr__(self):
29004 
    L = ['%s=%r' % (key, value)
29005 
      for key, value in self.__dict__.iteritems()]
29006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29007 
 
29008 
  def __eq__(self, other):
29009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29010 
 
29011 
  def __ne__(self, other):
29012 
    return not (self == other)
29013 
 
6031 rajveer 29014 
class getUserWalletHistory_args:
6000 mandeep.dh 29015 
  """
29016 
  Attributes:
6031 rajveer 29017 
   - userId
6000 mandeep.dh 29018 
  """
29019 
 
29020 
  thrift_spec = (
29021 
    None, # 0
6031 rajveer 29022 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 29023 
  )
29024 
 
6031 rajveer 29025 
  def __init__(self, userId=None,):
29026 
    self.userId = userId
6000 mandeep.dh 29027 
 
29028 
  def read(self, iprot):
29029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29031 
      return
29032 
    iprot.readStructBegin()
29033 
    while True:
29034 
      (fname, ftype, fid) = iprot.readFieldBegin()
29035 
      if ftype == TType.STOP:
29036 
        break
29037 
      if fid == 1:
29038 
        if ftype == TType.I64:
6031 rajveer 29039 
          self.userId = iprot.readI64();
6000 mandeep.dh 29040 
        else:
29041 
          iprot.skip(ftype)
29042 
      else:
29043 
        iprot.skip(ftype)
29044 
      iprot.readFieldEnd()
29045 
    iprot.readStructEnd()
29046 
 
29047 
  def write(self, oprot):
29048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29050 
      return
6031 rajveer 29051 
    oprot.writeStructBegin('getUserWalletHistory_args')
29052 
    if self.userId is not None:
29053 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29054 
      oprot.writeI64(self.userId)
6000 mandeep.dh 29055 
      oprot.writeFieldEnd()
29056 
    oprot.writeFieldStop()
29057 
    oprot.writeStructEnd()
29058 
 
29059 
  def validate(self):
29060 
    return
29061 
 
29062 
 
29063 
  def __repr__(self):
29064 
    L = ['%s=%r' % (key, value)
29065 
      for key, value in self.__dict__.iteritems()]
29066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29067 
 
29068 
  def __eq__(self, other):
29069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29070 
 
29071 
  def __ne__(self, other):
29072 
    return not (self == other)
29073 
 
6031 rajveer 29074 
class getUserWalletHistory_result:
6000 mandeep.dh 29075 
  """
29076 
  Attributes:
29077 
   - success
29078 
  """
29079 
 
29080 
  thrift_spec = (
6031 rajveer 29081 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 29082 
  )
29083 
 
29084 
  def __init__(self, success=None,):
29085 
    self.success = success
29086 
 
29087 
  def read(self, iprot):
29088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29090 
      return
29091 
    iprot.readStructBegin()
29092 
    while True:
29093 
      (fname, ftype, fid) = iprot.readFieldBegin()
29094 
      if ftype == TType.STOP:
29095 
        break
29096 
      if fid == 0:
29097 
        if ftype == TType.LIST:
29098 
          self.success = []
6188 rajveer 29099 
          (_etype666, _size663) = iprot.readListBegin()
29100 
          for _i667 in xrange(_size663):
29101 
            _elem668 = UserWalletHistory()
29102 
            _elem668.read(iprot)
29103 
            self.success.append(_elem668)
6000 mandeep.dh 29104 
          iprot.readListEnd()
29105 
        else:
29106 
          iprot.skip(ftype)
29107 
      else:
29108 
        iprot.skip(ftype)
29109 
      iprot.readFieldEnd()
29110 
    iprot.readStructEnd()
29111 
 
29112 
  def write(self, oprot):
29113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29115 
      return
6031 rajveer 29116 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 29117 
    if self.success is not None:
29118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29119 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29120 
      for iter669 in self.success:
29121 
        iter669.write(oprot)
6000 mandeep.dh 29122 
      oprot.writeListEnd()
29123 
      oprot.writeFieldEnd()
29124 
    oprot.writeFieldStop()
29125 
    oprot.writeStructEnd()
29126 
 
29127 
  def validate(self):
29128 
    return
29129 
 
29130 
 
29131 
  def __repr__(self):
29132 
    L = ['%s=%r' % (key, value)
29133 
      for key, value in self.__dict__.iteritems()]
29134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29135 
 
29136 
  def __eq__(self, other):
29137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29138 
 
29139 
  def __ne__(self, other):
29140 
    return not (self == other)
6048 rajveer 29141 
 
6050 anupam.sin 29142 
class getRechargeOrdersForTransaction_args:
29143 
  """
29144 
  Attributes:
29145 
   - txnId
29146 
  """
29147 
 
29148 
  thrift_spec = (
29149 
    None, # 0
29150 
    (1, TType.I64, 'txnId', None, None, ), # 1
29151 
  )
29152 
 
29153 
  def __init__(self, txnId=None,):
29154 
    self.txnId = txnId
29155 
 
29156 
  def read(self, iprot):
29157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29159 
      return
29160 
    iprot.readStructBegin()
29161 
    while True:
29162 
      (fname, ftype, fid) = iprot.readFieldBegin()
29163 
      if ftype == TType.STOP:
29164 
        break
29165 
      if fid == 1:
29166 
        if ftype == TType.I64:
29167 
          self.txnId = iprot.readI64();
29168 
        else:
29169 
          iprot.skip(ftype)
29170 
      else:
29171 
        iprot.skip(ftype)
29172 
      iprot.readFieldEnd()
29173 
    iprot.readStructEnd()
29174 
 
29175 
  def write(self, oprot):
29176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29178 
      return
29179 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
29180 
    if self.txnId is not None:
29181 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
29182 
      oprot.writeI64(self.txnId)
29183 
      oprot.writeFieldEnd()
29184 
    oprot.writeFieldStop()
29185 
    oprot.writeStructEnd()
29186 
 
29187 
  def validate(self):
29188 
    return
29189 
 
29190 
 
29191 
  def __repr__(self):
29192 
    L = ['%s=%r' % (key, value)
29193 
      for key, value in self.__dict__.iteritems()]
29194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29195 
 
29196 
  def __eq__(self, other):
29197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29198 
 
29199 
  def __ne__(self, other):
29200 
    return not (self == other)
29201 
 
29202 
class getRechargeOrdersForTransaction_result:
29203 
  """
29204 
  Attributes:
29205 
   - success
29206 
   - ex
29207 
  """
29208 
 
29209 
  thrift_spec = (
29210 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
29211 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29212 
  )
29213 
 
29214 
  def __init__(self, success=None, ex=None,):
29215 
    self.success = success
29216 
    self.ex = ex
29217 
 
29218 
  def read(self, iprot):
29219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29221 
      return
29222 
    iprot.readStructBegin()
29223 
    while True:
29224 
      (fname, ftype, fid) = iprot.readFieldBegin()
29225 
      if ftype == TType.STOP:
29226 
        break
29227 
      if fid == 0:
29228 
        if ftype == TType.STRUCT:
29229 
          self.success = RechargeOrder()
29230 
          self.success.read(iprot)
29231 
        else:
29232 
          iprot.skip(ftype)
29233 
      elif fid == 1:
29234 
        if ftype == TType.STRUCT:
29235 
          self.ex = TransactionServiceException()
29236 
          self.ex.read(iprot)
29237 
        else:
29238 
          iprot.skip(ftype)
29239 
      else:
29240 
        iprot.skip(ftype)
29241 
      iprot.readFieldEnd()
29242 
    iprot.readStructEnd()
29243 
 
29244 
  def write(self, oprot):
29245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29247 
      return
29248 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
29249 
    if self.success is not None:
29250 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29251 
      self.success.write(oprot)
29252 
      oprot.writeFieldEnd()
29253 
    if self.ex is not None:
29254 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29255 
      self.ex.write(oprot)
29256 
      oprot.writeFieldEnd()
29257 
    oprot.writeFieldStop()
29258 
    oprot.writeStructEnd()
29259 
 
29260 
  def validate(self):
29261 
    return
29262 
 
29263 
 
29264 
  def __repr__(self):
29265 
    L = ['%s=%r' % (key, value)
29266 
      for key, value in self.__dict__.iteritems()]
29267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29268 
 
29269 
  def __eq__(self, other):
29270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29271 
 
29272 
  def __ne__(self, other):
29273 
    return not (self == other)
29274 
 
6048 rajveer 29275 
class getServiceProviders_args:
29276 
  """
29277 
  Attributes:
29278 
   - rechargeType
6206 rajveer 29279 
   - onlyActive
6048 rajveer 29280 
  """
29281 
 
29282 
  thrift_spec = (
29283 
    None, # 0
29284 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 29285 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 29286 
  )
29287 
 
6206 rajveer 29288 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 29289 
    self.rechargeType = rechargeType
6206 rajveer 29290 
    self.onlyActive = onlyActive
6048 rajveer 29291 
 
29292 
  def read(self, iprot):
29293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29295 
      return
29296 
    iprot.readStructBegin()
29297 
    while True:
29298 
      (fname, ftype, fid) = iprot.readFieldBegin()
29299 
      if ftype == TType.STOP:
29300 
        break
29301 
      if fid == 1:
29302 
        if ftype == TType.I32:
29303 
          self.rechargeType = iprot.readI32();
29304 
        else:
29305 
          iprot.skip(ftype)
6206 rajveer 29306 
      elif fid == 2:
29307 
        if ftype == TType.BOOL:
29308 
          self.onlyActive = iprot.readBool();
29309 
        else:
29310 
          iprot.skip(ftype)
6048 rajveer 29311 
      else:
29312 
        iprot.skip(ftype)
29313 
      iprot.readFieldEnd()
29314 
    iprot.readStructEnd()
29315 
 
29316 
  def write(self, oprot):
29317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29319 
      return
29320 
    oprot.writeStructBegin('getServiceProviders_args')
29321 
    if self.rechargeType is not None:
29322 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29323 
      oprot.writeI32(self.rechargeType)
29324 
      oprot.writeFieldEnd()
6206 rajveer 29325 
    if self.onlyActive is not None:
29326 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
29327 
      oprot.writeBool(self.onlyActive)
29328 
      oprot.writeFieldEnd()
6048 rajveer 29329 
    oprot.writeFieldStop()
29330 
    oprot.writeStructEnd()
29331 
 
29332 
  def validate(self):
29333 
    return
29334 
 
29335 
 
29336 
  def __repr__(self):
29337 
    L = ['%s=%r' % (key, value)
29338 
      for key, value in self.__dict__.iteritems()]
29339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29340 
 
29341 
  def __eq__(self, other):
29342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29343 
 
29344 
  def __ne__(self, other):
29345 
    return not (self == other)
29346 
 
29347 
class getServiceProviders_result:
29348 
  """
29349 
  Attributes:
29350 
   - success
29351 
  """
29352 
 
29353 
  thrift_spec = (
29354 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
29355 
  )
29356 
 
29357 
  def __init__(self, success=None,):
29358 
    self.success = success
29359 
 
29360 
  def read(self, iprot):
29361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29363 
      return
29364 
    iprot.readStructBegin()
29365 
    while True:
29366 
      (fname, ftype, fid) = iprot.readFieldBegin()
29367 
      if ftype == TType.STOP:
29368 
        break
29369 
      if fid == 0:
29370 
        if ftype == TType.MAP:
29371 
          self.success = {}
6188 rajveer 29372 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
29373 
          for _i674 in xrange(_size670):
29374 
            _key675 = iprot.readI64();
29375 
            _val676 = iprot.readString();
29376 
            self.success[_key675] = _val676
6048 rajveer 29377 
          iprot.readMapEnd()
29378 
        else:
29379 
          iprot.skip(ftype)
29380 
      else:
29381 
        iprot.skip(ftype)
29382 
      iprot.readFieldEnd()
29383 
    iprot.readStructEnd()
29384 
 
29385 
  def write(self, oprot):
29386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29388 
      return
29389 
    oprot.writeStructBegin('getServiceProviders_result')
29390 
    if self.success is not None:
29391 
      oprot.writeFieldBegin('success', TType.MAP, 0)
29392 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 29393 
      for kiter677,viter678 in self.success.items():
29394 
        oprot.writeI64(kiter677)
29395 
        oprot.writeString(viter678)
6048 rajveer 29396 
      oprot.writeMapEnd()
29397 
      oprot.writeFieldEnd()
29398 
    oprot.writeFieldStop()
29399 
    oprot.writeStructEnd()
29400 
 
29401 
  def validate(self):
29402 
    return
29403 
 
29404 
 
29405 
  def __repr__(self):
29406 
    L = ['%s=%r' % (key, value)
29407 
      for key, value in self.__dict__.iteritems()]
29408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29409 
 
29410 
  def __eq__(self, other):
29411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29412 
 
29413 
  def __ne__(self, other):
29414 
    return not (self == other)
29415 
 
29416 
class getServiceProviderForDevice_args:
29417 
  """
29418 
  Attributes:
6049 rajveer 29419 
   - rechargeType
6048 rajveer 29420 
   - deviceNumber
29421 
  """
29422 
 
29423 
  thrift_spec = (
29424 
    None, # 0
6049 rajveer 29425 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
29426 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 29427 
  )
29428 
 
6049 rajveer 29429 
  def __init__(self, rechargeType=None, deviceNumber=None,):
29430 
    self.rechargeType = rechargeType
6048 rajveer 29431 
    self.deviceNumber = deviceNumber
29432 
 
29433 
  def read(self, iprot):
29434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29436 
      return
29437 
    iprot.readStructBegin()
29438 
    while True:
29439 
      (fname, ftype, fid) = iprot.readFieldBegin()
29440 
      if ftype == TType.STOP:
29441 
        break
29442 
      if fid == 1:
6049 rajveer 29443 
        if ftype == TType.I32:
29444 
          self.rechargeType = iprot.readI32();
29445 
        else:
29446 
          iprot.skip(ftype)
29447 
      elif fid == 2:
6048 rajveer 29448 
        if ftype == TType.STRING:
29449 
          self.deviceNumber = iprot.readString();
29450 
        else:
29451 
          iprot.skip(ftype)
29452 
      else:
29453 
        iprot.skip(ftype)
29454 
      iprot.readFieldEnd()
29455 
    iprot.readStructEnd()
29456 
 
29457 
  def write(self, oprot):
29458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29460 
      return
29461 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 29462 
    if self.rechargeType is not None:
29463 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29464 
      oprot.writeI32(self.rechargeType)
29465 
      oprot.writeFieldEnd()
6048 rajveer 29466 
    if self.deviceNumber is not None:
6049 rajveer 29467 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 29468 
      oprot.writeString(self.deviceNumber)
29469 
      oprot.writeFieldEnd()
29470 
    oprot.writeFieldStop()
29471 
    oprot.writeStructEnd()
29472 
 
29473 
  def validate(self):
29474 
    return
29475 
 
29476 
 
29477 
  def __repr__(self):
29478 
    L = ['%s=%r' % (key, value)
29479 
      for key, value in self.__dict__.iteritems()]
29480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29481 
 
29482 
  def __eq__(self, other):
29483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29484 
 
29485 
  def __ne__(self, other):
29486 
    return not (self == other)
29487 
 
29488 
class getServiceProviderForDevice_result:
29489 
  """
29490 
  Attributes:
29491 
   - success
29492 
  """
29493 
 
29494 
  thrift_spec = (
6289 anupam.sin 29495 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 29496 
  )
29497 
 
29498 
  def __init__(self, success=None,):
29499 
    self.success = success
29500 
 
29501 
  def read(self, iprot):
29502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29504 
      return
29505 
    iprot.readStructBegin()
29506 
    while True:
29507 
      (fname, ftype, fid) = iprot.readFieldBegin()
29508 
      if ftype == TType.STOP:
29509 
        break
29510 
      if fid == 0:
6289 anupam.sin 29511 
        if ftype == TType.STRUCT:
29512 
          self.success = DeviceNumberInfo()
29513 
          self.success.read(iprot)
6048 rajveer 29514 
        else:
29515 
          iprot.skip(ftype)
29516 
      else:
29517 
        iprot.skip(ftype)
29518 
      iprot.readFieldEnd()
29519 
    iprot.readStructEnd()
29520 
 
29521 
  def write(self, oprot):
29522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29524 
      return
29525 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
29526 
    if self.success is not None:
6289 anupam.sin 29527 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29528 
      self.success.write(oprot)
6048 rajveer 29529 
      oprot.writeFieldEnd()
29530 
    oprot.writeFieldStop()
29531 
    oprot.writeStructEnd()
29532 
 
29533 
  def validate(self):
29534 
    return
29535 
 
29536 
 
29537 
  def __repr__(self):
29538 
    L = ['%s=%r' % (key, value)
29539 
      for key, value in self.__dict__.iteritems()]
29540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29541 
 
29542 
  def __eq__(self, other):
29543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29544 
 
29545 
  def __ne__(self, other):
29546 
    return not (self == other)
6094 rajveer 29547 
 
6269 rajveer 29548 
class validateRecharge_args:
29549 
  """
29550 
  Attributes:
29551 
   - rechargeType
29552 
   - deviceNumber
6307 anupam.sin 29553 
   - userSelectedProviderId
6591 anupam.sin 29554 
   - clientAddress
6269 rajveer 29555 
  """
29556 
 
29557 
  thrift_spec = (
29558 
    None, # 0
29559 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
29560 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 29561 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 29562 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 29563 
  )
29564 
 
6591 anupam.sin 29565 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 29566 
    self.rechargeType = rechargeType
29567 
    self.deviceNumber = deviceNumber
6307 anupam.sin 29568 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 29569 
    self.clientAddress = clientAddress
6269 rajveer 29570 
 
29571 
  def read(self, iprot):
29572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29574 
      return
29575 
    iprot.readStructBegin()
29576 
    while True:
29577 
      (fname, ftype, fid) = iprot.readFieldBegin()
29578 
      if ftype == TType.STOP:
29579 
        break
29580 
      if fid == 1:
29581 
        if ftype == TType.I32:
29582 
          self.rechargeType = iprot.readI32();
29583 
        else:
29584 
          iprot.skip(ftype)
29585 
      elif fid == 2:
29586 
        if ftype == TType.STRING:
29587 
          self.deviceNumber = iprot.readString();
29588 
        else:
29589 
          iprot.skip(ftype)
6307 anupam.sin 29590 
      elif fid == 3:
29591 
        if ftype == TType.I64:
29592 
          self.userSelectedProviderId = iprot.readI64();
29593 
        else:
29594 
          iprot.skip(ftype)
6591 anupam.sin 29595 
      elif fid == 4:
29596 
        if ftype == TType.STRING:
29597 
          self.clientAddress = iprot.readString();
29598 
        else:
29599 
          iprot.skip(ftype)
6269 rajveer 29600 
      else:
29601 
        iprot.skip(ftype)
29602 
      iprot.readFieldEnd()
29603 
    iprot.readStructEnd()
29604 
 
29605 
  def write(self, oprot):
29606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29608 
      return
29609 
    oprot.writeStructBegin('validateRecharge_args')
29610 
    if self.rechargeType is not None:
29611 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29612 
      oprot.writeI32(self.rechargeType)
29613 
      oprot.writeFieldEnd()
29614 
    if self.deviceNumber is not None:
29615 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
29616 
      oprot.writeString(self.deviceNumber)
29617 
      oprot.writeFieldEnd()
6307 anupam.sin 29618 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 29619 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 29620 
      oprot.writeI64(self.userSelectedProviderId)
29621 
      oprot.writeFieldEnd()
6591 anupam.sin 29622 
    if self.clientAddress is not None:
29623 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
29624 
      oprot.writeString(self.clientAddress)
29625 
      oprot.writeFieldEnd()
6269 rajveer 29626 
    oprot.writeFieldStop()
29627 
    oprot.writeStructEnd()
29628 
 
29629 
  def validate(self):
29630 
    return
29631 
 
29632 
 
29633 
  def __repr__(self):
29634 
    L = ['%s=%r' % (key, value)
29635 
      for key, value in self.__dict__.iteritems()]
29636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29637 
 
29638 
  def __eq__(self, other):
29639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29640 
 
29641 
  def __ne__(self, other):
29642 
    return not (self == other)
29643 
 
29644 
class validateRecharge_result:
29645 
  """
29646 
  Attributes:
29647 
   - success
29648 
  """
29649 
 
29650 
  thrift_spec = (
29651 
    (0, TType.STRING, 'success', None, None, ), # 0
29652 
  )
29653 
 
29654 
  def __init__(self, success=None,):
29655 
    self.success = success
29656 
 
29657 
  def read(self, iprot):
29658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29660 
      return
29661 
    iprot.readStructBegin()
29662 
    while True:
29663 
      (fname, ftype, fid) = iprot.readFieldBegin()
29664 
      if ftype == TType.STOP:
29665 
        break
29666 
      if fid == 0:
29667 
        if ftype == TType.STRING:
29668 
          self.success = iprot.readString();
29669 
        else:
29670 
          iprot.skip(ftype)
29671 
      else:
29672 
        iprot.skip(ftype)
29673 
      iprot.readFieldEnd()
29674 
    iprot.readStructEnd()
29675 
 
29676 
  def write(self, oprot):
29677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29679 
      return
29680 
    oprot.writeStructBegin('validateRecharge_result')
29681 
    if self.success is not None:
29682 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29683 
      oprot.writeString(self.success)
29684 
      oprot.writeFieldEnd()
29685 
    oprot.writeFieldStop()
29686 
    oprot.writeStructEnd()
29687 
 
29688 
  def validate(self):
29689 
    return
29690 
 
29691 
 
29692 
  def __repr__(self):
29693 
    L = ['%s=%r' % (key, value)
29694 
      for key, value in self.__dict__.iteritems()]
29695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29696 
 
29697 
  def __eq__(self, other):
29698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29699 
 
29700 
  def __ne__(self, other):
29701 
    return not (self == other)
29702 
 
6094 rajveer 29703 
class getRechargeOrdersForDevice_args:
29704 
  """
29705 
  Attributes:
29706 
   - deviceNumber
29707 
  """
29708 
 
29709 
  thrift_spec = (
29710 
    None, # 0
29711 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
29712 
  )
29713 
 
29714 
  def __init__(self, deviceNumber=None,):
29715 
    self.deviceNumber = deviceNumber
29716 
 
29717 
  def read(self, iprot):
29718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29720 
      return
29721 
    iprot.readStructBegin()
29722 
    while True:
29723 
      (fname, ftype, fid) = iprot.readFieldBegin()
29724 
      if ftype == TType.STOP:
29725 
        break
29726 
      if fid == 1:
29727 
        if ftype == TType.STRING:
29728 
          self.deviceNumber = iprot.readString();
29729 
        else:
29730 
          iprot.skip(ftype)
29731 
      else:
29732 
        iprot.skip(ftype)
29733 
      iprot.readFieldEnd()
29734 
    iprot.readStructEnd()
29735 
 
29736 
  def write(self, oprot):
29737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29739 
      return
29740 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
29741 
    if self.deviceNumber is not None:
29742 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
29743 
      oprot.writeString(self.deviceNumber)
29744 
      oprot.writeFieldEnd()
29745 
    oprot.writeFieldStop()
29746 
    oprot.writeStructEnd()
29747 
 
29748 
  def validate(self):
29749 
    return
29750 
 
29751 
 
29752 
  def __repr__(self):
29753 
    L = ['%s=%r' % (key, value)
29754 
      for key, value in self.__dict__.iteritems()]
29755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29756 
 
29757 
  def __eq__(self, other):
29758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29759 
 
29760 
  def __ne__(self, other):
29761 
    return not (self == other)
29762 
 
29763 
class getRechargeOrdersForDevice_result:
29764 
  """
29765 
  Attributes:
29766 
   - success
29767 
  """
29768 
 
29769 
  thrift_spec = (
29770 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29771 
  )
29772 
 
29773 
  def __init__(self, success=None,):
29774 
    self.success = success
29775 
 
29776 
  def read(self, iprot):
29777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29779 
      return
29780 
    iprot.readStructBegin()
29781 
    while True:
29782 
      (fname, ftype, fid) = iprot.readFieldBegin()
29783 
      if ftype == TType.STOP:
29784 
        break
29785 
      if fid == 0:
29786 
        if ftype == TType.LIST:
29787 
          self.success = []
6188 rajveer 29788 
          (_etype682, _size679) = iprot.readListBegin()
29789 
          for _i683 in xrange(_size679):
29790 
            _elem684 = RechargeOrder()
29791 
            _elem684.read(iprot)
29792 
            self.success.append(_elem684)
6094 rajveer 29793 
          iprot.readListEnd()
29794 
        else:
29795 
          iprot.skip(ftype)
29796 
      else:
29797 
        iprot.skip(ftype)
29798 
      iprot.readFieldEnd()
29799 
    iprot.readStructEnd()
29800 
 
29801 
  def write(self, oprot):
29802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29804 
      return
29805 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
29806 
    if self.success is not None:
29807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29808 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29809 
      for iter685 in self.success:
29810 
        iter685.write(oprot)
6094 rajveer 29811 
      oprot.writeListEnd()
29812 
      oprot.writeFieldEnd()
29813 
    oprot.writeFieldStop()
29814 
    oprot.writeStructEnd()
29815 
 
29816 
  def validate(self):
29817 
    return
29818 
 
29819 
 
29820 
  def __repr__(self):
29821 
    L = ['%s=%r' % (key, value)
29822 
      for key, value in self.__dict__.iteritems()]
29823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29824 
 
29825 
  def __eq__(self, other):
29826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29827 
 
29828 
  def __ne__(self, other):
29829 
    return not (self == other)
29830 
 
29831 
class addAmountToWallet_args:
29832 
  """
29833 
  Attributes:
29834 
   - userId
29835 
   - orderId
29836 
   - amount
29837 
  """
29838 
 
29839 
  thrift_spec = (
29840 
    None, # 0
29841 
    (1, TType.I64, 'userId', None, None, ), # 1
29842 
    (2, TType.I64, 'orderId', None, None, ), # 2
29843 
    (3, TType.I64, 'amount', None, None, ), # 3
29844 
  )
29845 
 
29846 
  def __init__(self, userId=None, orderId=None, amount=None,):
29847 
    self.userId = userId
29848 
    self.orderId = orderId
29849 
    self.amount = amount
29850 
 
29851 
  def read(self, iprot):
29852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29854 
      return
29855 
    iprot.readStructBegin()
29856 
    while True:
29857 
      (fname, ftype, fid) = iprot.readFieldBegin()
29858 
      if ftype == TType.STOP:
29859 
        break
29860 
      if fid == 1:
29861 
        if ftype == TType.I64:
29862 
          self.userId = iprot.readI64();
29863 
        else:
29864 
          iprot.skip(ftype)
29865 
      elif fid == 2:
29866 
        if ftype == TType.I64:
29867 
          self.orderId = iprot.readI64();
29868 
        else:
29869 
          iprot.skip(ftype)
29870 
      elif fid == 3:
29871 
        if ftype == TType.I64:
29872 
          self.amount = iprot.readI64();
29873 
        else:
29874 
          iprot.skip(ftype)
29875 
      else:
29876 
        iprot.skip(ftype)
29877 
      iprot.readFieldEnd()
29878 
    iprot.readStructEnd()
29879 
 
29880 
  def write(self, oprot):
29881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29883 
      return
29884 
    oprot.writeStructBegin('addAmountToWallet_args')
29885 
    if self.userId is not None:
29886 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29887 
      oprot.writeI64(self.userId)
29888 
      oprot.writeFieldEnd()
29889 
    if self.orderId is not None:
29890 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29891 
      oprot.writeI64(self.orderId)
29892 
      oprot.writeFieldEnd()
29893 
    if self.amount is not None:
29894 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29895 
      oprot.writeI64(self.amount)
29896 
      oprot.writeFieldEnd()
29897 
    oprot.writeFieldStop()
29898 
    oprot.writeStructEnd()
29899 
 
29900 
  def validate(self):
29901 
    return
29902 
 
29903 
 
29904 
  def __repr__(self):
29905 
    L = ['%s=%r' % (key, value)
29906 
      for key, value in self.__dict__.iteritems()]
29907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29908 
 
29909 
  def __eq__(self, other):
29910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29911 
 
29912 
  def __ne__(self, other):
29913 
    return not (self == other)
29914 
 
29915 
class addAmountToWallet_result:
29916 
 
29917 
  thrift_spec = (
29918 
  )
29919 
 
29920 
  def read(self, iprot):
29921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29923 
      return
29924 
    iprot.readStructBegin()
29925 
    while True:
29926 
      (fname, ftype, fid) = iprot.readFieldBegin()
29927 
      if ftype == TType.STOP:
29928 
        break
29929 
      else:
29930 
        iprot.skip(ftype)
29931 
      iprot.readFieldEnd()
29932 
    iprot.readStructEnd()
29933 
 
29934 
  def write(self, oprot):
29935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29937 
      return
29938 
    oprot.writeStructBegin('addAmountToWallet_result')
29939 
    oprot.writeFieldStop()
29940 
    oprot.writeStructEnd()
29941 
 
29942 
  def validate(self):
29943 
    return
29944 
 
29945 
 
29946 
  def __repr__(self):
29947 
    L = ['%s=%r' % (key, value)
29948 
      for key, value in self.__dict__.iteritems()]
29949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29950 
 
29951 
  def __eq__(self, other):
29952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29953 
 
29954 
  def __ne__(self, other):
29955 
    return not (self == other)
6154 rajveer 29956 
 
6188 rajveer 29957 
class getRechargeStatistics_args:
29958 
 
29959 
  thrift_spec = (
29960 
  )
29961 
 
29962 
  def read(self, iprot):
29963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29965 
      return
29966 
    iprot.readStructBegin()
29967 
    while True:
29968 
      (fname, ftype, fid) = iprot.readFieldBegin()
29969 
      if ftype == TType.STOP:
29970 
        break
29971 
      else:
29972 
        iprot.skip(ftype)
29973 
      iprot.readFieldEnd()
29974 
    iprot.readStructEnd()
29975 
 
29976 
  def write(self, oprot):
29977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29979 
      return
29980 
    oprot.writeStructBegin('getRechargeStatistics_args')
29981 
    oprot.writeFieldStop()
29982 
    oprot.writeStructEnd()
29983 
 
29984 
  def validate(self):
29985 
    return
29986 
 
29987 
 
29988 
  def __repr__(self):
29989 
    L = ['%s=%r' % (key, value)
29990 
      for key, value in self.__dict__.iteritems()]
29991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29992 
 
29993 
  def __eq__(self, other):
29994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29995 
 
29996 
  def __ne__(self, other):
29997 
    return not (self == other)
29998 
 
29999 
class getRechargeStatistics_result:
30000 
  """
30001 
  Attributes:
30002 
   - success
30003 
  """
30004 
 
30005 
  thrift_spec = (
30006 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
30007 
  )
30008 
 
30009 
  def __init__(self, success=None,):
30010 
    self.success = success
30011 
 
30012 
  def read(self, iprot):
30013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30015 
      return
30016 
    iprot.readStructBegin()
30017 
    while True:
30018 
      (fname, ftype, fid) = iprot.readFieldBegin()
30019 
      if ftype == TType.STOP:
30020 
        break
30021 
      if fid == 0:
30022 
        if ftype == TType.STRUCT:
30023 
          self.success = RechargeStatistics()
30024 
          self.success.read(iprot)
30025 
        else:
30026 
          iprot.skip(ftype)
30027 
      else:
30028 
        iprot.skip(ftype)
30029 
      iprot.readFieldEnd()
30030 
    iprot.readStructEnd()
30031 
 
30032 
  def write(self, oprot):
30033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30035 
      return
30036 
    oprot.writeStructBegin('getRechargeStatistics_result')
30037 
    if self.success is not None:
30038 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30039 
      self.success.write(oprot)
30040 
      oprot.writeFieldEnd()
30041 
    oprot.writeFieldStop()
30042 
    oprot.writeStructEnd()
30043 
 
30044 
  def validate(self):
30045 
    return
30046 
 
30047 
 
30048 
  def __repr__(self):
30049 
    L = ['%s=%r' % (key, value)
30050 
      for key, value in self.__dict__.iteritems()]
30051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30052 
 
30053 
  def __eq__(self, other):
30054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30055 
 
30056 
  def __ne__(self, other):
30057 
    return not (self == other)
30058 
 
6154 rajveer 30059 
class getRechargeOrdersForStatus_args:
30060 
  """
30061 
  Attributes:
30062 
   - status
30063 
  """
30064 
 
30065 
  thrift_spec = (
30066 
    None, # 0
30067 
    (1, TType.I64, 'status', None, None, ), # 1
30068 
  )
30069 
 
30070 
  def __init__(self, status=None,):
30071 
    self.status = status
30072 
 
30073 
  def read(self, iprot):
30074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30076 
      return
30077 
    iprot.readStructBegin()
30078 
    while True:
30079 
      (fname, ftype, fid) = iprot.readFieldBegin()
30080 
      if ftype == TType.STOP:
30081 
        break
30082 
      if fid == 1:
30083 
        if ftype == TType.I64:
30084 
          self.status = iprot.readI64();
30085 
        else:
30086 
          iprot.skip(ftype)
30087 
      else:
30088 
        iprot.skip(ftype)
30089 
      iprot.readFieldEnd()
30090 
    iprot.readStructEnd()
30091 
 
30092 
  def write(self, oprot):
30093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30095 
      return
30096 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
30097 
    if self.status is not None:
30098 
      oprot.writeFieldBegin('status', TType.I64, 1)
30099 
      oprot.writeI64(self.status)
30100 
      oprot.writeFieldEnd()
30101 
    oprot.writeFieldStop()
30102 
    oprot.writeStructEnd()
30103 
 
30104 
  def validate(self):
30105 
    return
30106 
 
30107 
 
30108 
  def __repr__(self):
30109 
    L = ['%s=%r' % (key, value)
30110 
      for key, value in self.__dict__.iteritems()]
30111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30112 
 
30113 
  def __eq__(self, other):
30114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30115 
 
30116 
  def __ne__(self, other):
30117 
    return not (self == other)
30118 
 
30119 
class getRechargeOrdersForStatus_result:
30120 
  """
30121 
  Attributes:
30122 
   - success
30123 
  """
30124 
 
30125 
  thrift_spec = (
30126 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
30127 
  )
30128 
 
30129 
  def __init__(self, success=None,):
30130 
    self.success = success
30131 
 
30132 
  def read(self, iprot):
30133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30135 
      return
30136 
    iprot.readStructBegin()
30137 
    while True:
30138 
      (fname, ftype, fid) = iprot.readFieldBegin()
30139 
      if ftype == TType.STOP:
30140 
        break
30141 
      if fid == 0:
30142 
        if ftype == TType.LIST:
30143 
          self.success = []
6188 rajveer 30144 
          (_etype689, _size686) = iprot.readListBegin()
30145 
          for _i690 in xrange(_size686):
30146 
            _elem691 = RechargeOrder()
30147 
            _elem691.read(iprot)
30148 
            self.success.append(_elem691)
6154 rajveer 30149 
          iprot.readListEnd()
30150 
        else:
30151 
          iprot.skip(ftype)
30152 
      else:
30153 
        iprot.skip(ftype)
30154 
      iprot.readFieldEnd()
30155 
    iprot.readStructEnd()
30156 
 
30157 
  def write(self, oprot):
30158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30160 
      return
30161 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
30162 
    if self.success is not None:
30163 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30164 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 30165 
      for iter692 in self.success:
30166 
        iter692.write(oprot)
6154 rajveer 30167 
      oprot.writeListEnd()
30168 
      oprot.writeFieldEnd()
30169 
    oprot.writeFieldStop()
30170 
    oprot.writeStructEnd()
30171 
 
30172 
  def validate(self):
30173 
    return
30174 
 
30175 
 
30176 
  def __repr__(self):
30177 
    L = ['%s=%r' % (key, value)
30178 
      for key, value in self.__dict__.iteritems()]
30179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30180 
 
30181 
  def __eq__(self, other):
30182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30183 
 
30184 
  def __ne__(self, other):
30185 
    return not (self == other)
6159 rajveer 30186 
 
30187 
class getPlansForOperator_args:
30188 
  """
30189 
  Attributes:
30190 
   - operatorId
30191 
  """
30192 
 
30193 
  thrift_spec = (
30194 
    None, # 0
30195 
    (1, TType.I64, 'operatorId', None, None, ), # 1
30196 
  )
30197 
 
30198 
  def __init__(self, operatorId=None,):
30199 
    self.operatorId = operatorId
30200 
 
30201 
  def read(self, iprot):
30202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30204 
      return
30205 
    iprot.readStructBegin()
30206 
    while True:
30207 
      (fname, ftype, fid) = iprot.readFieldBegin()
30208 
      if ftype == TType.STOP:
30209 
        break
30210 
      if fid == 1:
30211 
        if ftype == TType.I64:
30212 
          self.operatorId = iprot.readI64();
30213 
        else:
30214 
          iprot.skip(ftype)
30215 
      else:
30216 
        iprot.skip(ftype)
30217 
      iprot.readFieldEnd()
30218 
    iprot.readStructEnd()
30219 
 
30220 
  def write(self, oprot):
30221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30223 
      return
30224 
    oprot.writeStructBegin('getPlansForOperator_args')
30225 
    if self.operatorId is not None:
30226 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30227 
      oprot.writeI64(self.operatorId)
30228 
      oprot.writeFieldEnd()
30229 
    oprot.writeFieldStop()
30230 
    oprot.writeStructEnd()
30231 
 
30232 
  def validate(self):
30233 
    return
30234 
 
30235 
 
30236 
  def __repr__(self):
30237 
    L = ['%s=%r' % (key, value)
30238 
      for key, value in self.__dict__.iteritems()]
30239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30240 
 
30241 
  def __eq__(self, other):
30242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30243 
 
30244 
  def __ne__(self, other):
30245 
    return not (self == other)
30246 
 
30247 
class getPlansForOperator_result:
30248 
  """
30249 
  Attributes:
30250 
   - success
30251 
  """
30252 
 
30253 
  thrift_spec = (
30254 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
30255 
  )
30256 
 
30257 
  def __init__(self, success=None,):
30258 
    self.success = success
30259 
 
30260 
  def read(self, iprot):
30261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30263 
      return
30264 
    iprot.readStructBegin()
30265 
    while True:
30266 
      (fname, ftype, fid) = iprot.readFieldBegin()
30267 
      if ftype == TType.STOP:
30268 
        break
30269 
      if fid == 0:
30270 
        if ftype == TType.LIST:
30271 
          self.success = []
6188 rajveer 30272 
          (_etype696, _size693) = iprot.readListBegin()
30273 
          for _i697 in xrange(_size693):
30274 
            _elem698 = RechargePlan()
30275 
            _elem698.read(iprot)
30276 
            self.success.append(_elem698)
6159 rajveer 30277 
          iprot.readListEnd()
30278 
        else:
30279 
          iprot.skip(ftype)
30280 
      else:
30281 
        iprot.skip(ftype)
30282 
      iprot.readFieldEnd()
30283 
    iprot.readStructEnd()
30284 
 
30285 
  def write(self, oprot):
30286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30288 
      return
30289 
    oprot.writeStructBegin('getPlansForOperator_result')
30290 
    if self.success is not None:
30291 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30292 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 30293 
      for iter699 in self.success:
30294 
        iter699.write(oprot)
6159 rajveer 30295 
      oprot.writeListEnd()
30296 
      oprot.writeFieldEnd()
30297 
    oprot.writeFieldStop()
30298 
    oprot.writeStructEnd()
30299 
 
30300 
  def validate(self):
30301 
    return
30302 
 
30303 
 
30304 
  def __repr__(self):
30305 
    L = ['%s=%r' % (key, value)
30306 
      for key, value in self.__dict__.iteritems()]
30307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30308 
 
30309 
  def __eq__(self, other):
30310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30311 
 
30312 
  def __ne__(self, other):
30313 
    return not (self == other)
6289 anupam.sin 30314 
 
30315 
class getRechargeDenominations_args:
30316 
  """
30317 
  Attributes:
30318 
   - operatorId
6307 anupam.sin 30319 
   - circleCode
6289 anupam.sin 30320 
   - denominationType
30321 
  """
30322 
 
30323 
  thrift_spec = (
30324 
    None, # 0
30325 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 30326 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 30327 
    (3, TType.I32, 'denominationType', None, None, ), # 3
30328 
  )
30329 
 
6307 anupam.sin 30330 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 30331 
    self.operatorId = operatorId
6307 anupam.sin 30332 
    self.circleCode = circleCode
6289 anupam.sin 30333 
    self.denominationType = denominationType
30334 
 
30335 
  def read(self, iprot):
30336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30338 
      return
30339 
    iprot.readStructBegin()
30340 
    while True:
30341 
      (fname, ftype, fid) = iprot.readFieldBegin()
30342 
      if ftype == TType.STOP:
30343 
        break
30344 
      if fid == 1:
30345 
        if ftype == TType.I64:
30346 
          self.operatorId = iprot.readI64();
30347 
        else:
30348 
          iprot.skip(ftype)
30349 
      elif fid == 2:
30350 
        if ftype == TType.STRING:
6307 anupam.sin 30351 
          self.circleCode = iprot.readString();
6289 anupam.sin 30352 
        else:
30353 
          iprot.skip(ftype)
30354 
      elif fid == 3:
30355 
        if ftype == TType.I32:
30356 
          self.denominationType = iprot.readI32();
30357 
        else:
30358 
          iprot.skip(ftype)
30359 
      else:
30360 
        iprot.skip(ftype)
30361 
      iprot.readFieldEnd()
30362 
    iprot.readStructEnd()
30363 
 
30364 
  def write(self, oprot):
30365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30367 
      return
30368 
    oprot.writeStructBegin('getRechargeDenominations_args')
30369 
    if self.operatorId is not None:
30370 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30371 
      oprot.writeI64(self.operatorId)
30372 
      oprot.writeFieldEnd()
6307 anupam.sin 30373 
    if self.circleCode is not None:
30374 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
30375 
      oprot.writeString(self.circleCode)
6289 anupam.sin 30376 
      oprot.writeFieldEnd()
30377 
    if self.denominationType is not None:
30378 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
30379 
      oprot.writeI32(self.denominationType)
30380 
      oprot.writeFieldEnd()
30381 
    oprot.writeFieldStop()
30382 
    oprot.writeStructEnd()
30383 
 
30384 
  def validate(self):
30385 
    return
30386 
 
30387 
 
30388 
  def __repr__(self):
30389 
    L = ['%s=%r' % (key, value)
30390 
      for key, value in self.__dict__.iteritems()]
30391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30392 
 
30393 
  def __eq__(self, other):
30394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30395 
 
30396 
  def __ne__(self, other):
30397 
    return not (self == other)
30398 
 
30399 
class getRechargeDenominations_result:
30400 
  """
30401 
  Attributes:
30402 
   - success
30403 
   - ex
30404 
  """
30405 
 
30406 
  thrift_spec = (
30407 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
30408 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30409 
  )
30410 
 
30411 
  def __init__(self, success=None, ex=None,):
30412 
    self.success = success
30413 
    self.ex = ex
30414 
 
30415 
  def read(self, iprot):
30416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30418 
      return
30419 
    iprot.readStructBegin()
30420 
    while True:
30421 
      (fname, ftype, fid) = iprot.readFieldBegin()
30422 
      if ftype == TType.STOP:
30423 
        break
30424 
      if fid == 0:
30425 
        if ftype == TType.LIST:
30426 
          self.success = []
30427 
          (_etype703, _size700) = iprot.readListBegin()
30428 
          for _i704 in xrange(_size700):
30429 
            _elem705 = RechargeDenomination()
30430 
            _elem705.read(iprot)
30431 
            self.success.append(_elem705)
30432 
          iprot.readListEnd()
30433 
        else:
30434 
          iprot.skip(ftype)
30435 
      elif fid == 1:
30436 
        if ftype == TType.STRUCT:
30437 
          self.ex = TransactionServiceException()
30438 
          self.ex.read(iprot)
30439 
        else:
30440 
          iprot.skip(ftype)
30441 
      else:
30442 
        iprot.skip(ftype)
30443 
      iprot.readFieldEnd()
30444 
    iprot.readStructEnd()
30445 
 
30446 
  def write(self, oprot):
30447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30449 
      return
30450 
    oprot.writeStructBegin('getRechargeDenominations_result')
30451 
    if self.success is not None:
30452 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30453 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30454 
      for iter706 in self.success:
30455 
        iter706.write(oprot)
30456 
      oprot.writeListEnd()
30457 
      oprot.writeFieldEnd()
30458 
    if self.ex is not None:
30459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30460 
      self.ex.write(oprot)
30461 
      oprot.writeFieldEnd()
30462 
    oprot.writeFieldStop()
30463 
    oprot.writeStructEnd()
30464 
 
30465 
  def validate(self):
30466 
    return
30467 
 
30468 
 
30469 
  def __repr__(self):
30470 
    L = ['%s=%r' % (key, value)
30471 
      for key, value in self.__dict__.iteritems()]
30472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30473 
 
30474 
  def __eq__(self, other):
30475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30476 
 
30477 
  def __ne__(self, other):
30478 
    return not (self == other)
6371 rajveer 30479 
 
30480 
class updateAvailabilityStatus_args:
30481 
  """
30482 
  Attributes:
30483 
   - operatorId
30484 
   - circleId
30485 
   - isAvailable
30486 
  """
30487 
 
30488 
  thrift_spec = (
30489 
    None, # 0
30490 
    (1, TType.I64, 'operatorId', None, None, ), # 1
30491 
    (2, TType.I64, 'circleId', None, None, ), # 2
30492 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
30493 
  )
30494 
 
30495 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
30496 
    self.operatorId = operatorId
30497 
    self.circleId = circleId
30498 
    self.isAvailable = isAvailable
30499 
 
30500 
  def read(self, iprot):
30501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30503 
      return
30504 
    iprot.readStructBegin()
30505 
    while True:
30506 
      (fname, ftype, fid) = iprot.readFieldBegin()
30507 
      if ftype == TType.STOP:
30508 
        break
30509 
      if fid == 1:
30510 
        if ftype == TType.I64:
30511 
          self.operatorId = iprot.readI64();
30512 
        else:
30513 
          iprot.skip(ftype)
30514 
      elif fid == 2:
30515 
        if ftype == TType.I64:
30516 
          self.circleId = iprot.readI64();
30517 
        else:
30518 
          iprot.skip(ftype)
30519 
      elif fid == 3:
30520 
        if ftype == TType.BOOL:
30521 
          self.isAvailable = iprot.readBool();
30522 
        else:
30523 
          iprot.skip(ftype)
30524 
      else:
30525 
        iprot.skip(ftype)
30526 
      iprot.readFieldEnd()
30527 
    iprot.readStructEnd()
30528 
 
30529 
  def write(self, oprot):
30530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30532 
      return
30533 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
30534 
    if self.operatorId is not None:
30535 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30536 
      oprot.writeI64(self.operatorId)
30537 
      oprot.writeFieldEnd()
30538 
    if self.circleId is not None:
30539 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
30540 
      oprot.writeI64(self.circleId)
30541 
      oprot.writeFieldEnd()
30542 
    if self.isAvailable is not None:
30543 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
30544 
      oprot.writeBool(self.isAvailable)
30545 
      oprot.writeFieldEnd()
30546 
    oprot.writeFieldStop()
30547 
    oprot.writeStructEnd()
30548 
 
30549 
  def validate(self):
30550 
    return
30551 
 
30552 
 
30553 
  def __repr__(self):
30554 
    L = ['%s=%r' % (key, value)
30555 
      for key, value in self.__dict__.iteritems()]
30556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30557 
 
30558 
  def __eq__(self, other):
30559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30560 
 
30561 
  def __ne__(self, other):
30562 
    return not (self == other)
30563 
 
30564 
class updateAvailabilityStatus_result:
30565 
 
30566 
  thrift_spec = (
30567 
  )
30568 
 
30569 
  def read(self, iprot):
30570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30572 
      return
30573 
    iprot.readStructBegin()
30574 
    while True:
30575 
      (fname, ftype, fid) = iprot.readFieldBegin()
30576 
      if ftype == TType.STOP:
30577 
        break
30578 
      else:
30579 
        iprot.skip(ftype)
30580 
      iprot.readFieldEnd()
30581 
    iprot.readStructEnd()
30582 
 
30583 
  def write(self, oprot):
30584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30586 
      return
30587 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
30588 
    oprot.writeFieldStop()
30589 
    oprot.writeStructEnd()
30590 
 
30591 
  def validate(self):
30592 
    return
30593 
 
30594 
 
30595 
  def __repr__(self):
30596 
    L = ['%s=%r' % (key, value)
30597 
      for key, value in self.__dict__.iteritems()]
30598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30599 
 
30600 
  def __eq__(self, other):
30601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30602 
 
30603 
  def __ne__(self, other):
30604 
    return not (self == other)
6389 rajveer 30605 
 
30606 
class getAvailableEmiSchemes_args:
30607 
 
30608 
  thrift_spec = (
30609 
  )
30610 
 
30611 
  def read(self, iprot):
30612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30614 
      return
30615 
    iprot.readStructBegin()
30616 
    while True:
30617 
      (fname, ftype, fid) = iprot.readFieldBegin()
30618 
      if ftype == TType.STOP:
30619 
        break
30620 
      else:
30621 
        iprot.skip(ftype)
30622 
      iprot.readFieldEnd()
30623 
    iprot.readStructEnd()
30624 
 
30625 
  def write(self, oprot):
30626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30628 
      return
30629 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
30630 
    oprot.writeFieldStop()
30631 
    oprot.writeStructEnd()
30632 
 
30633 
  def validate(self):
30634 
    return
30635 
 
30636 
 
30637 
  def __repr__(self):
30638 
    L = ['%s=%r' % (key, value)
30639 
      for key, value in self.__dict__.iteritems()]
30640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30641 
 
30642 
  def __eq__(self, other):
30643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30644 
 
30645 
  def __ne__(self, other):
30646 
    return not (self == other)
30647 
 
30648 
class getAvailableEmiSchemes_result:
30649 
  """
30650 
  Attributes:
30651 
   - success
30652 
  """
30653 
 
30654 
  thrift_spec = (
30655 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
30656 
  )
30657 
 
30658 
  def __init__(self, success=None,):
30659 
    self.success = success
30660 
 
30661 
  def read(self, iprot):
30662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30664 
      return
30665 
    iprot.readStructBegin()
30666 
    while True:
30667 
      (fname, ftype, fid) = iprot.readFieldBegin()
30668 
      if ftype == TType.STOP:
30669 
        break
30670 
      if fid == 0:
30671 
        if ftype == TType.LIST:
30672 
          self.success = []
30673 
          (_etype710, _size707) = iprot.readListBegin()
30674 
          for _i711 in xrange(_size707):
30675 
            _elem712 = EmiScheme()
30676 
            _elem712.read(iprot)
30677 
            self.success.append(_elem712)
30678 
          iprot.readListEnd()
30679 
        else:
30680 
          iprot.skip(ftype)
30681 
      else:
30682 
        iprot.skip(ftype)
30683 
      iprot.readFieldEnd()
30684 
    iprot.readStructEnd()
30685 
 
30686 
  def write(self, oprot):
30687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30689 
      return
30690 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
30691 
    if self.success is not None:
30692 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30693 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30694 
      for iter713 in self.success:
30695 
        iter713.write(oprot)
30696 
      oprot.writeListEnd()
30697 
      oprot.writeFieldEnd()
30698 
    oprot.writeFieldStop()
30699 
    oprot.writeStructEnd()
30700 
 
30701 
  def validate(self):
30702 
    return
30703 
 
30704 
 
30705 
  def __repr__(self):
30706 
    L = ['%s=%r' % (key, value)
30707 
      for key, value in self.__dict__.iteritems()]
30708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30709 
 
30710 
  def __eq__(self, other):
30711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30712 
 
30713 
  def __ne__(self, other):
30714 
    return not (self == other)
30715 
 
30716 
class getMiscCharges_args:
30717 
  """
30718 
  Attributes:
30719 
   - transactionId
30720 
  """
30721 
 
30722 
  thrift_spec = (
30723 
    None, # 0
30724 
    (1, TType.I64, 'transactionId', None, None, ), # 1
30725 
  )
30726 
 
30727 
  def __init__(self, transactionId=None,):
30728 
    self.transactionId = transactionId
30729 
 
30730 
  def read(self, iprot):
30731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30733 
      return
30734 
    iprot.readStructBegin()
30735 
    while True:
30736 
      (fname, ftype, fid) = iprot.readFieldBegin()
30737 
      if ftype == TType.STOP:
30738 
        break
30739 
      if fid == 1:
30740 
        if ftype == TType.I64:
30741 
          self.transactionId = iprot.readI64();
30742 
        else:
30743 
          iprot.skip(ftype)
30744 
      else:
30745 
        iprot.skip(ftype)
30746 
      iprot.readFieldEnd()
30747 
    iprot.readStructEnd()
30748 
 
30749 
  def write(self, oprot):
30750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30752 
      return
30753 
    oprot.writeStructBegin('getMiscCharges_args')
30754 
    if self.transactionId is not None:
30755 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
30756 
      oprot.writeI64(self.transactionId)
30757 
      oprot.writeFieldEnd()
30758 
    oprot.writeFieldStop()
30759 
    oprot.writeStructEnd()
30760 
 
30761 
  def validate(self):
30762 
    return
30763 
 
30764 
 
30765 
  def __repr__(self):
30766 
    L = ['%s=%r' % (key, value)
30767 
      for key, value in self.__dict__.iteritems()]
30768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30769 
 
30770 
  def __eq__(self, other):
30771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30772 
 
30773 
  def __ne__(self, other):
30774 
    return not (self == other)
30775 
 
30776 
class getMiscCharges_result:
30777 
  """
30778 
  Attributes:
30779 
   - success
30780 
  """
30781 
 
30782 
  thrift_spec = (
6412 rajveer 30783 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 30784 
  )
30785 
 
30786 
  def __init__(self, success=None,):
30787 
    self.success = success
30788 
 
30789 
  def read(self, iprot):
30790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30792 
      return
30793 
    iprot.readStructBegin()
30794 
    while True:
30795 
      (fname, ftype, fid) = iprot.readFieldBegin()
30796 
      if ftype == TType.STOP:
30797 
        break
30798 
      if fid == 0:
30799 
        if ftype == TType.MAP:
30800 
          self.success = {}
30801 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
30802 
          for _i718 in xrange(_size714):
30803 
            _key719 = iprot.readI64();
6412 rajveer 30804 
            _val720 = iprot.readDouble();
6389 rajveer 30805 
            self.success[_key719] = _val720
30806 
          iprot.readMapEnd()
30807 
        else:
30808 
          iprot.skip(ftype)
30809 
      else:
30810 
        iprot.skip(ftype)
30811 
      iprot.readFieldEnd()
30812 
    iprot.readStructEnd()
30813 
 
30814 
  def write(self, oprot):
30815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30817 
      return
30818 
    oprot.writeStructBegin('getMiscCharges_result')
30819 
    if self.success is not None:
30820 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 30821 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 30822 
      for kiter721,viter722 in self.success.items():
30823 
        oprot.writeI64(kiter721)
6412 rajveer 30824 
        oprot.writeDouble(viter722)
6389 rajveer 30825 
      oprot.writeMapEnd()
30826 
      oprot.writeFieldEnd()
30827 
    oprot.writeFieldStop()
30828 
    oprot.writeStructEnd()
30829 
 
30830 
  def validate(self):
30831 
    return
30832 
 
30833 
 
30834 
  def __repr__(self):
30835 
    L = ['%s=%r' % (key, value)
30836 
      for key, value in self.__dict__.iteritems()]
30837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30838 
 
30839 
  def __eq__(self, other):
30840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30841 
 
30842 
  def __ne__(self, other):
30843 
    return not (self == other)
6507 anupam.sin 30844 
 
30845 
class refundRechargeOrder_args:
30846 
  """
30847 
  Attributes:
30848 
   - rechargeOrderId
30849 
  """
30850 
 
30851 
  thrift_spec = (
30852 
    None, # 0
30853 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30854 
  )
30855 
 
30856 
  def __init__(self, rechargeOrderId=None,):
30857 
    self.rechargeOrderId = rechargeOrderId
30858 
 
30859 
  def read(self, iprot):
30860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30862 
      return
30863 
    iprot.readStructBegin()
30864 
    while True:
30865 
      (fname, ftype, fid) = iprot.readFieldBegin()
30866 
      if ftype == TType.STOP:
30867 
        break
30868 
      if fid == 1:
30869 
        if ftype == TType.I64:
30870 
          self.rechargeOrderId = iprot.readI64();
30871 
        else:
30872 
          iprot.skip(ftype)
30873 
      else:
30874 
        iprot.skip(ftype)
30875 
      iprot.readFieldEnd()
30876 
    iprot.readStructEnd()
30877 
 
30878 
  def write(self, oprot):
30879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30881 
      return
30882 
    oprot.writeStructBegin('refundRechargeOrder_args')
30883 
    if self.rechargeOrderId is not None:
30884 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30885 
      oprot.writeI64(self.rechargeOrderId)
30886 
      oprot.writeFieldEnd()
30887 
    oprot.writeFieldStop()
30888 
    oprot.writeStructEnd()
30889 
 
30890 
  def validate(self):
30891 
    return
30892 
 
30893 
 
30894 
  def __repr__(self):
30895 
    L = ['%s=%r' % (key, value)
30896 
      for key, value in self.__dict__.iteritems()]
30897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30898 
 
30899 
  def __eq__(self, other):
30900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30901 
 
30902 
  def __ne__(self, other):
30903 
    return not (self == other)
30904 
 
30905 
class refundRechargeOrder_result:
30906 
  """
30907 
  Attributes:
30908 
   - success
30909 
   - ex
30910 
  """
30911 
 
30912 
  thrift_spec = (
30913 
    (0, TType.BOOL, 'success', None, None, ), # 0
30914 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30915 
  )
30916 
 
30917 
  def __init__(self, success=None, ex=None,):
30918 
    self.success = success
30919 
    self.ex = ex
30920 
 
30921 
  def read(self, iprot):
30922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30924 
      return
30925 
    iprot.readStructBegin()
30926 
    while True:
30927 
      (fname, ftype, fid) = iprot.readFieldBegin()
30928 
      if ftype == TType.STOP:
30929 
        break
30930 
      if fid == 0:
30931 
        if ftype == TType.BOOL:
30932 
          self.success = iprot.readBool();
30933 
        else:
30934 
          iprot.skip(ftype)
30935 
      elif fid == 1:
30936 
        if ftype == TType.STRUCT:
30937 
          self.ex = TransactionServiceException()
30938 
          self.ex.read(iprot)
30939 
        else:
30940 
          iprot.skip(ftype)
30941 
      else:
30942 
        iprot.skip(ftype)
30943 
      iprot.readFieldEnd()
30944 
    iprot.readStructEnd()
30945 
 
30946 
  def write(self, oprot):
30947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30949 
      return
30950 
    oprot.writeStructBegin('refundRechargeOrder_result')
30951 
    if self.success is not None:
30952 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30953 
      oprot.writeBool(self.success)
30954 
      oprot.writeFieldEnd()
30955 
    if self.ex is not None:
30956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30957 
      self.ex.write(oprot)
30958 
      oprot.writeFieldEnd()
30959 
    oprot.writeFieldStop()
30960 
    oprot.writeStructEnd()
30961 
 
30962 
  def validate(self):
30963 
    return
30964 
 
30965 
 
30966 
  def __repr__(self):
30967 
    L = ['%s=%r' % (key, value)
30968 
      for key, value in self.__dict__.iteritems()]
30969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30970 
 
30971 
  def __eq__(self, other):
30972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30973 
 
30974 
  def __ne__(self, other):
30975 
    return not (self == other)
6821 amar.kumar 30976 
 
30977 
class getPhysicalOrders_args:
30978 
  """
30979 
  Attributes:
30980 
   - fromDate
30981 
   - toDate
30982 
  """
30983 
 
30984 
  thrift_spec = (
30985 
    None, # 0
30986 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30987 
    (2, TType.I64, 'toDate', None, None, ), # 2
30988 
  )
30989 
 
30990 
  def __init__(self, fromDate=None, toDate=None,):
30991 
    self.fromDate = fromDate
30992 
    self.toDate = toDate
30993 
 
30994 
  def read(self, iprot):
30995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30997 
      return
30998 
    iprot.readStructBegin()
30999 
    while True:
31000 
      (fname, ftype, fid) = iprot.readFieldBegin()
31001 
      if ftype == TType.STOP:
31002 
        break
31003 
      if fid == 1:
31004 
        if ftype == TType.I64:
31005 
          self.fromDate = iprot.readI64();
31006 
        else:
31007 
          iprot.skip(ftype)
31008 
      elif fid == 2:
31009 
        if ftype == TType.I64:
31010 
          self.toDate = iprot.readI64();
31011 
        else:
31012 
          iprot.skip(ftype)
31013 
      else:
31014 
        iprot.skip(ftype)
31015 
      iprot.readFieldEnd()
31016 
    iprot.readStructEnd()
31017 
 
31018 
  def write(self, oprot):
31019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31021 
      return
31022 
    oprot.writeStructBegin('getPhysicalOrders_args')
31023 
    if self.fromDate is not None:
31024 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
31025 
      oprot.writeI64(self.fromDate)
31026 
      oprot.writeFieldEnd()
31027 
    if self.toDate is not None:
31028 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
31029 
      oprot.writeI64(self.toDate)
31030 
      oprot.writeFieldEnd()
31031 
    oprot.writeFieldStop()
31032 
    oprot.writeStructEnd()
31033 
 
31034 
  def validate(self):
31035 
    return
31036 
 
31037 
 
31038 
  def __repr__(self):
31039 
    L = ['%s=%r' % (key, value)
31040 
      for key, value in self.__dict__.iteritems()]
31041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31042 
 
31043 
  def __eq__(self, other):
31044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31045 
 
31046 
  def __ne__(self, other):
31047 
    return not (self == other)
31048 
 
31049 
class getPhysicalOrders_result:
31050 
  """
31051 
  Attributes:
31052 
   - success
31053 
  """
31054 
 
31055 
  thrift_spec = (
31056 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
31057 
  )
31058 
 
31059 
  def __init__(self, success=None,):
31060 
    self.success = success
31061 
 
31062 
  def read(self, iprot):
31063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31065 
      return
31066 
    iprot.readStructBegin()
31067 
    while True:
31068 
      (fname, ftype, fid) = iprot.readFieldBegin()
31069 
      if ftype == TType.STOP:
31070 
        break
31071 
      if fid == 0:
31072 
        if ftype == TType.LIST:
31073 
          self.success = []
31074 
          (_etype726, _size723) = iprot.readListBegin()
31075 
          for _i727 in xrange(_size723):
31076 
            _elem728 = Order()
31077 
            _elem728.read(iprot)
31078 
            self.success.append(_elem728)
31079 
          iprot.readListEnd()
31080 
        else:
31081 
          iprot.skip(ftype)
31082 
      else:
31083 
        iprot.skip(ftype)
31084 
      iprot.readFieldEnd()
31085 
    iprot.readStructEnd()
31086 
 
31087 
  def write(self, oprot):
31088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31090 
      return
31091 
    oprot.writeStructBegin('getPhysicalOrders_result')
31092 
    if self.success is not None:
31093 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31094 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31095 
      for iter729 in self.success:
31096 
        iter729.write(oprot)
31097 
      oprot.writeListEnd()
31098 
      oprot.writeFieldEnd()
31099 
    oprot.writeFieldStop()
31100 
    oprot.writeStructEnd()
31101 
 
31102 
  def validate(self):
31103 
    return
31104 
 
31105 
 
31106 
  def __repr__(self):
31107 
    L = ['%s=%r' % (key, value)
31108 
      for key, value in self.__dict__.iteritems()]
31109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31110 
 
31111 
  def __eq__(self, other):
31112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31113 
 
31114 
  def __ne__(self, other):
31115 
    return not (self == other)
6906 rajveer 31116 
 
31117 
class getDocument_args:
31118 
  """
31119 
  Attributes:
31120 
   - docType
31121 
   - docSource
31122 
  """
31123 
 
31124 
  thrift_spec = (
31125 
    None, # 0
31126 
    (1, TType.I64, 'docType', None, None, ), # 1
31127 
    (2, TType.I64, 'docSource', None, None, ), # 2
31128 
  )
31129 
 
31130 
  def __init__(self, docType=None, docSource=None,):
31131 
    self.docType = docType
31132 
    self.docSource = docSource
31133 
 
31134 
  def read(self, iprot):
31135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31137 
      return
31138 
    iprot.readStructBegin()
31139 
    while True:
31140 
      (fname, ftype, fid) = iprot.readFieldBegin()
31141 
      if ftype == TType.STOP:
31142 
        break
31143 
      if fid == 1:
31144 
        if ftype == TType.I64:
31145 
          self.docType = iprot.readI64();
31146 
        else:
31147 
          iprot.skip(ftype)
31148 
      elif fid == 2:
31149 
        if ftype == TType.I64:
31150 
          self.docSource = iprot.readI64();
31151 
        else:
31152 
          iprot.skip(ftype)
31153 
      else:
31154 
        iprot.skip(ftype)
31155 
      iprot.readFieldEnd()
31156 
    iprot.readStructEnd()
31157 
 
31158 
  def write(self, oprot):
31159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31161 
      return
31162 
    oprot.writeStructBegin('getDocument_args')
31163 
    if self.docType is not None:
31164 
      oprot.writeFieldBegin('docType', TType.I64, 1)
31165 
      oprot.writeI64(self.docType)
31166 
      oprot.writeFieldEnd()
31167 
    if self.docSource is not None:
31168 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
31169 
      oprot.writeI64(self.docSource)
31170 
      oprot.writeFieldEnd()
31171 
    oprot.writeFieldStop()
31172 
    oprot.writeStructEnd()
31173 
 
31174 
  def validate(self):
31175 
    return
31176 
 
31177 
 
31178 
  def __repr__(self):
31179 
    L = ['%s=%r' % (key, value)
31180 
      for key, value in self.__dict__.iteritems()]
31181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31182 
 
31183 
  def __eq__(self, other):
31184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31185 
 
31186 
  def __ne__(self, other):
31187 
    return not (self == other)
31188 
 
31189 
class getDocument_result:
31190 
  """
31191 
  Attributes:
31192 
   - success
31193 
  """
31194 
 
31195 
  thrift_spec = (
31196 
    (0, TType.STRING, 'success', None, None, ), # 0
31197 
  )
31198 
 
31199 
  def __init__(self, success=None,):
31200 
    self.success = success
31201 
 
31202 
  def read(self, iprot):
31203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31205 
      return
31206 
    iprot.readStructBegin()
31207 
    while True:
31208 
      (fname, ftype, fid) = iprot.readFieldBegin()
31209 
      if ftype == TType.STOP:
31210 
        break
31211 
      if fid == 0:
31212 
        if ftype == TType.STRING:
31213 
          self.success = iprot.readString();
31214 
        else:
31215 
          iprot.skip(ftype)
31216 
      else:
31217 
        iprot.skip(ftype)
31218 
      iprot.readFieldEnd()
31219 
    iprot.readStructEnd()
31220 
 
31221 
  def write(self, oprot):
31222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31224 
      return
31225 
    oprot.writeStructBegin('getDocument_result')
31226 
    if self.success is not None:
31227 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31228 
      oprot.writeString(self.success)
31229 
      oprot.writeFieldEnd()
31230 
    oprot.writeFieldStop()
31231 
    oprot.writeStructEnd()
31232 
 
31233 
  def validate(self):
31234 
    return
31235 
 
31236 
 
31237 
  def __repr__(self):
31238 
    L = ['%s=%r' % (key, value)
31239 
      for key, value in self.__dict__.iteritems()]
31240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31241 
 
31242 
  def __eq__(self, other):
31243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31244 
 
31245 
  def __ne__(self, other):
31246 
    return not (self == other)
6985 anupam.sin 31247 
 
31248 
class changeShippingAddress_args:
31249 
  """
31250 
  Attributes:
31251 
   - orderId
31252 
   - line1
31253 
   - line2
31254 
   - city
31255 
   - state
31256 
   - pin
31257 
  """
31258 
 
31259 
  thrift_spec = (
31260 
    None, # 0
31261 
    (1, TType.I64, 'orderId', None, None, ), # 1
31262 
    (2, TType.STRING, 'line1', None, None, ), # 2
31263 
    (3, TType.STRING, 'line2', None, None, ), # 3
31264 
    (4, TType.STRING, 'city', None, None, ), # 4
31265 
    (5, TType.STRING, 'state', None, None, ), # 5
31266 
    (6, TType.STRING, 'pin', None, None, ), # 6
31267 
  )
31268 
 
31269 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
31270 
    self.orderId = orderId
31271 
    self.line1 = line1
31272 
    self.line2 = line2
31273 
    self.city = city
31274 
    self.state = state
31275 
    self.pin = pin
31276 
 
31277 
  def read(self, iprot):
31278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31280 
      return
31281 
    iprot.readStructBegin()
31282 
    while True:
31283 
      (fname, ftype, fid) = iprot.readFieldBegin()
31284 
      if ftype == TType.STOP:
31285 
        break
31286 
      if fid == 1:
31287 
        if ftype == TType.I64:
31288 
          self.orderId = iprot.readI64();
31289 
        else:
31290 
          iprot.skip(ftype)
31291 
      elif fid == 2:
31292 
        if ftype == TType.STRING:
31293 
          self.line1 = iprot.readString();
31294 
        else:
31295 
          iprot.skip(ftype)
31296 
      elif fid == 3:
31297 
        if ftype == TType.STRING:
31298 
          self.line2 = iprot.readString();
31299 
        else:
31300 
          iprot.skip(ftype)
31301 
      elif fid == 4:
31302 
        if ftype == TType.STRING:
31303 
          self.city = iprot.readString();
31304 
        else:
31305 
          iprot.skip(ftype)
31306 
      elif fid == 5:
31307 
        if ftype == TType.STRING:
31308 
          self.state = iprot.readString();
31309 
        else:
31310 
          iprot.skip(ftype)
31311 
      elif fid == 6:
31312 
        if ftype == TType.STRING:
31313 
          self.pin = iprot.readString();
31314 
        else:
31315 
          iprot.skip(ftype)
31316 
      else:
31317 
        iprot.skip(ftype)
31318 
      iprot.readFieldEnd()
31319 
    iprot.readStructEnd()
31320 
 
31321 
  def write(self, oprot):
31322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31324 
      return
31325 
    oprot.writeStructBegin('changeShippingAddress_args')
31326 
    if self.orderId is not None:
31327 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
31328 
      oprot.writeI64(self.orderId)
31329 
      oprot.writeFieldEnd()
31330 
    if self.line1 is not None:
31331 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
31332 
      oprot.writeString(self.line1)
31333 
      oprot.writeFieldEnd()
31334 
    if self.line2 is not None:
31335 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
31336 
      oprot.writeString(self.line2)
31337 
      oprot.writeFieldEnd()
31338 
    if self.city is not None:
31339 
      oprot.writeFieldBegin('city', TType.STRING, 4)
31340 
      oprot.writeString(self.city)
31341 
      oprot.writeFieldEnd()
31342 
    if self.state is not None:
31343 
      oprot.writeFieldBegin('state', TType.STRING, 5)
31344 
      oprot.writeString(self.state)
31345 
      oprot.writeFieldEnd()
31346 
    if self.pin is not None:
31347 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
31348 
      oprot.writeString(self.pin)
31349 
      oprot.writeFieldEnd()
31350 
    oprot.writeFieldStop()
31351 
    oprot.writeStructEnd()
31352 
 
31353 
  def validate(self):
31354 
    return
31355 
 
31356 
 
31357 
  def __repr__(self):
31358 
    L = ['%s=%r' % (key, value)
31359 
      for key, value in self.__dict__.iteritems()]
31360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31361 
 
31362 
  def __eq__(self, other):
31363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31364 
 
31365 
  def __ne__(self, other):
31366 
    return not (self == other)
31367 
 
31368 
class changeShippingAddress_result:
31369 
  """
31370 
  Attributes:
31371 
   - success
31372 
  """
31373 
 
31374 
  thrift_spec = (
31375 
    (0, TType.BOOL, 'success', None, None, ), # 0
31376 
  )
31377 
 
31378 
  def __init__(self, success=None,):
31379 
    self.success = success
31380 
 
31381 
  def read(self, iprot):
31382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31384 
      return
31385 
    iprot.readStructBegin()
31386 
    while True:
31387 
      (fname, ftype, fid) = iprot.readFieldBegin()
31388 
      if ftype == TType.STOP:
31389 
        break
31390 
      if fid == 0:
31391 
        if ftype == TType.BOOL:
31392 
          self.success = iprot.readBool();
31393 
        else:
31394 
          iprot.skip(ftype)
31395 
      else:
31396 
        iprot.skip(ftype)
31397 
      iprot.readFieldEnd()
31398 
    iprot.readStructEnd()
31399 
 
31400 
  def write(self, oprot):
31401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31403 
      return
31404 
    oprot.writeStructBegin('changeShippingAddress_result')
31405 
    if self.success is not None:
31406 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
31407 
      oprot.writeBool(self.success)
31408 
      oprot.writeFieldEnd()
31409 
    oprot.writeFieldStop()
31410 
    oprot.writeStructEnd()
31411 
 
31412 
  def validate(self):
31413 
    return
31414 
 
31415 
 
31416 
  def __repr__(self):
31417 
    L = ['%s=%r' % (key, value)
31418 
      for key, value in self.__dict__.iteritems()]
31419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31420 
 
31421 
  def __eq__(self, other):
31422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31423 
 
31424 
  def __ne__(self, other):
31425 
    return not (self == other)
6988 rajveer 31426 
 
31427 
class retrieveInvoice_args:
31428 
  """
31429 
  Attributes:
31430 
   - orderId
7075 rajveer 31431 
   - userId
6988 rajveer 31432 
  """
31433 
 
31434 
  thrift_spec = (
31435 
    None, # 0
31436 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 31437 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 31438 
  )
31439 
 
7075 rajveer 31440 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 31441 
    self.orderId = orderId
7075 rajveer 31442 
    self.userId = userId
6988 rajveer 31443 
 
31444 
  def read(self, iprot):
31445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31447 
      return
31448 
    iprot.readStructBegin()
31449 
    while True:
31450 
      (fname, ftype, fid) = iprot.readFieldBegin()
31451 
      if ftype == TType.STOP:
31452 
        break
31453 
      if fid == 1:
31454 
        if ftype == TType.I64:
31455 
          self.orderId = iprot.readI64();
31456 
        else:
31457 
          iprot.skip(ftype)
7075 rajveer 31458 
      elif fid == 2:
31459 
        if ftype == TType.I64:
31460 
          self.userId = iprot.readI64();
31461 
        else:
31462 
          iprot.skip(ftype)
6988 rajveer 31463 
      else:
31464 
        iprot.skip(ftype)
31465 
      iprot.readFieldEnd()
31466 
    iprot.readStructEnd()
31467 
 
31468 
  def write(self, oprot):
31469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31471 
      return
31472 
    oprot.writeStructBegin('retrieveInvoice_args')
31473 
    if self.orderId is not None:
31474 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
31475 
      oprot.writeI64(self.orderId)
31476 
      oprot.writeFieldEnd()
7075 rajveer 31477 
    if self.userId is not None:
31478 
      oprot.writeFieldBegin('userId', TType.I64, 2)
31479 
      oprot.writeI64(self.userId)
31480 
      oprot.writeFieldEnd()
6988 rajveer 31481 
    oprot.writeFieldStop()
31482 
    oprot.writeStructEnd()
31483 
 
31484 
  def validate(self):
31485 
    return
31486 
 
31487 
 
31488 
  def __repr__(self):
31489 
    L = ['%s=%r' % (key, value)
31490 
      for key, value in self.__dict__.iteritems()]
31491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31492 
 
31493 
  def __eq__(self, other):
31494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31495 
 
31496 
  def __ne__(self, other):
31497 
    return not (self == other)
31498 
 
31499 
class retrieveInvoice_result:
31500 
  """
31501 
  Attributes:
31502 
   - success
31503 
  """
31504 
 
31505 
  thrift_spec = (
31506 
    (0, TType.STRING, 'success', None, None, ), # 0
31507 
  )
31508 
 
31509 
  def __init__(self, success=None,):
31510 
    self.success = success
31511 
 
31512 
  def read(self, iprot):
31513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31515 
      return
31516 
    iprot.readStructBegin()
31517 
    while True:
31518 
      (fname, ftype, fid) = iprot.readFieldBegin()
31519 
      if ftype == TType.STOP:
31520 
        break
31521 
      if fid == 0:
31522 
        if ftype == TType.STRING:
31523 
          self.success = iprot.readString();
31524 
        else:
31525 
          iprot.skip(ftype)
31526 
      else:
31527 
        iprot.skip(ftype)
31528 
      iprot.readFieldEnd()
31529 
    iprot.readStructEnd()
31530 
 
31531 
  def write(self, oprot):
31532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31534 
      return
31535 
    oprot.writeStructBegin('retrieveInvoice_result')
31536 
    if self.success is not None:
31537 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31538 
      oprot.writeString(self.success)
31539 
      oprot.writeFieldEnd()
31540 
    oprot.writeFieldStop()
31541 
    oprot.writeStructEnd()
31542 
 
31543 
  def validate(self):
31544 
    return
31545 
 
31546 
 
31547 
  def __repr__(self):
31548 
    L = ['%s=%r' % (key, value)
31549 
      for key, value in self.__dict__.iteritems()]
31550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31551 
 
31552 
  def __eq__(self, other):
31553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31554 
 
31555 
  def __ne__(self, other):
31556 
    return not (self == other)
7026 rajveer 31557 
 
31558 
class receiveUpdatesForRedExpress_args:
31559 
  """
31560 
  Attributes:
31561 
   - awbNumber
31562 
  """
31563 
 
31564 
  thrift_spec = (
31565 
    None, # 0
31566 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
31567 
  )
31568 
 
31569 
  def __init__(self, awbNumber=None,):
31570 
    self.awbNumber = awbNumber
31571 
 
31572 
  def read(self, iprot):
31573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31575 
      return
31576 
    iprot.readStructBegin()
31577 
    while True:
31578 
      (fname, ftype, fid) = iprot.readFieldBegin()
31579 
      if ftype == TType.STOP:
31580 
        break
31581 
      if fid == 1:
31582 
        if ftype == TType.STRING:
31583 
          self.awbNumber = iprot.readString();
31584 
        else:
31585 
          iprot.skip(ftype)
31586 
      else:
31587 
        iprot.skip(ftype)
31588 
      iprot.readFieldEnd()
31589 
    iprot.readStructEnd()
31590 
 
31591 
  def write(self, oprot):
31592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31594 
      return
31595 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
31596 
    if self.awbNumber is not None:
31597 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
31598 
      oprot.writeString(self.awbNumber)
31599 
      oprot.writeFieldEnd()
31600 
    oprot.writeFieldStop()
31601 
    oprot.writeStructEnd()
31602 
 
31603 
  def validate(self):
31604 
    return
31605 
 
31606 
 
31607 
  def __repr__(self):
31608 
    L = ['%s=%r' % (key, value)
31609 
      for key, value in self.__dict__.iteritems()]
31610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31611 
 
31612 
  def __eq__(self, other):
31613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31614 
 
31615 
  def __ne__(self, other):
31616 
    return not (self == other)
31617 
 
31618 
class receiveUpdatesForRedExpress_result:
31619 
  """
31620 
  Attributes:
31621 
   - success
31622 
  """
31623 
 
31624 
  thrift_spec = (
31625 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
31626 
  )
31627 
 
31628 
  def __init__(self, success=None,):
31629 
    self.success = success
31630 
 
31631 
  def read(self, iprot):
31632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31634 
      return
31635 
    iprot.readStructBegin()
31636 
    while True:
31637 
      (fname, ftype, fid) = iprot.readFieldBegin()
31638 
      if ftype == TType.STOP:
31639 
        break
31640 
      if fid == 0:
31641 
        if ftype == TType.LIST:
31642 
          self.success = []
31643 
          (_etype733, _size730) = iprot.readListBegin()
31644 
          for _i734 in xrange(_size730):
31645 
            _elem735 = iprot.readString();
31646 
            self.success.append(_elem735)
31647 
          iprot.readListEnd()
31648 
        else:
31649 
          iprot.skip(ftype)
31650 
      else:
31651 
        iprot.skip(ftype)
31652 
      iprot.readFieldEnd()
31653 
    iprot.readStructEnd()
31654 
 
31655 
  def write(self, oprot):
31656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31658 
      return
31659 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
31660 
    if self.success is not None:
31661 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31662 
      oprot.writeListBegin(TType.STRING, len(self.success))
31663 
      for iter736 in self.success:
31664 
        oprot.writeString(iter736)
31665 
      oprot.writeListEnd()
31666 
      oprot.writeFieldEnd()
31667 
    oprot.writeFieldStop()
31668 
    oprot.writeStructEnd()
31669 
 
31670 
  def validate(self):
31671 
    return
31672 
 
31673 
 
31674 
  def __repr__(self):
31675 
    L = ['%s=%r' % (key, value)
31676 
      for key, value in self.__dict__.iteritems()]
31677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31678 
 
31679 
  def __eq__(self, other):
31680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31681 
 
31682 
  def __ne__(self, other):
31683 
    return not (self == other)
7073 anupam.sin 31684 
 
31685 
class createRechargeTransaction_args:
31686 
  """
31687 
  Attributes:
31688 
   - thriftRechargeTransaction
31689 
  """
31690 
 
31691 
  thrift_spec = (
31692 
    None, # 0
31693 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
31694 
  )
31695 
 
31696 
  def __init__(self, thriftRechargeTransaction=None,):
31697 
    self.thriftRechargeTransaction = thriftRechargeTransaction
31698 
 
31699 
  def read(self, iprot):
31700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31702 
      return
31703 
    iprot.readStructBegin()
31704 
    while True:
31705 
      (fname, ftype, fid) = iprot.readFieldBegin()
31706 
      if ftype == TType.STOP:
31707 
        break
31708 
      if fid == 1:
31709 
        if ftype == TType.STRUCT:
31710 
          self.thriftRechargeTransaction = RechargeTransaction()
31711 
          self.thriftRechargeTransaction.read(iprot)
31712 
        else:
31713 
          iprot.skip(ftype)
31714 
      else:
31715 
        iprot.skip(ftype)
31716 
      iprot.readFieldEnd()
31717 
    iprot.readStructEnd()
31718 
 
31719 
  def write(self, oprot):
31720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31722 
      return
31723 
    oprot.writeStructBegin('createRechargeTransaction_args')
31724 
    if self.thriftRechargeTransaction is not None:
31725 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
31726 
      self.thriftRechargeTransaction.write(oprot)
31727 
      oprot.writeFieldEnd()
31728 
    oprot.writeFieldStop()
31729 
    oprot.writeStructEnd()
31730 
 
31731 
  def validate(self):
31732 
    return
31733 
 
31734 
 
31735 
  def __repr__(self):
31736 
    L = ['%s=%r' % (key, value)
31737 
      for key, value in self.__dict__.iteritems()]
31738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31739 
 
31740 
  def __eq__(self, other):
31741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31742 
 
31743 
  def __ne__(self, other):
31744 
    return not (self == other)
31745 
 
31746 
class createRechargeTransaction_result:
31747 
  """
31748 
  Attributes:
31749 
   - success
31750 
  """
31751 
 
31752 
  thrift_spec = (
31753 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31754 
  )
31755 
 
31756 
  def __init__(self, success=None,):
31757 
    self.success = success
31758 
 
31759 
  def read(self, iprot):
31760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31762 
      return
31763 
    iprot.readStructBegin()
31764 
    while True:
31765 
      (fname, ftype, fid) = iprot.readFieldBegin()
31766 
      if ftype == TType.STOP:
31767 
        break
31768 
      if fid == 0:
31769 
        if ftype == TType.STRUCT:
31770 
          self.success = RechargeTransaction()
31771 
          self.success.read(iprot)
31772 
        else:
31773 
          iprot.skip(ftype)
31774 
      else:
31775 
        iprot.skip(ftype)
31776 
      iprot.readFieldEnd()
31777 
    iprot.readStructEnd()
31778 
 
31779 
  def write(self, oprot):
31780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31782 
      return
31783 
    oprot.writeStructBegin('createRechargeTransaction_result')
31784 
    if self.success is not None:
31785 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31786 
      self.success.write(oprot)
31787 
      oprot.writeFieldEnd()
31788 
    oprot.writeFieldStop()
31789 
    oprot.writeStructEnd()
31790 
 
31791 
  def validate(self):
31792 
    return
31793 
 
31794 
 
31795 
  def __repr__(self):
31796 
    L = ['%s=%r' % (key, value)
31797 
      for key, value in self.__dict__.iteritems()]
31798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31799 
 
31800 
  def __eq__(self, other):
31801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31802 
 
31803 
  def __ne__(self, other):
31804 
    return not (self == other)
7080 anupam.sin 31805 
 
7085 rajveer 31806 
class getRechargeTransactions_args:
31807 
  """
31808 
  Attributes:
31809 
   - storeId
31810 
  """
31811 
 
31812 
  thrift_spec = (
31813 
    None, # 0
31814 
    (1, TType.I64, 'storeId', None, None, ), # 1
31815 
  )
31816 
 
31817 
  def __init__(self, storeId=None,):
31818 
    self.storeId = storeId
31819 
 
31820 
  def read(self, iprot):
31821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31823 
      return
31824 
    iprot.readStructBegin()
31825 
    while True:
31826 
      (fname, ftype, fid) = iprot.readFieldBegin()
31827 
      if ftype == TType.STOP:
31828 
        break
31829 
      if fid == 1:
31830 
        if ftype == TType.I64:
31831 
          self.storeId = iprot.readI64();
31832 
        else:
31833 
          iprot.skip(ftype)
31834 
      else:
31835 
        iprot.skip(ftype)
31836 
      iprot.readFieldEnd()
31837 
    iprot.readStructEnd()
31838 
 
31839 
  def write(self, oprot):
31840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31842 
      return
31843 
    oprot.writeStructBegin('getRechargeTransactions_args')
31844 
    if self.storeId is not None:
31845 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31846 
      oprot.writeI64(self.storeId)
31847 
      oprot.writeFieldEnd()
31848 
    oprot.writeFieldStop()
31849 
    oprot.writeStructEnd()
31850 
 
31851 
  def validate(self):
31852 
    return
31853 
 
31854 
 
31855 
  def __repr__(self):
31856 
    L = ['%s=%r' % (key, value)
31857 
      for key, value in self.__dict__.iteritems()]
31858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31859 
 
31860 
  def __eq__(self, other):
31861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31862 
 
31863 
  def __ne__(self, other):
31864 
    return not (self == other)
31865 
 
31866 
class getRechargeTransactions_result:
31867 
  """
31868 
  Attributes:
31869 
   - success
31870 
  """
31871 
 
31872 
  thrift_spec = (
31873 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31874 
  )
31875 
 
31876 
  def __init__(self, success=None,):
31877 
    self.success = success
31878 
 
31879 
  def read(self, iprot):
31880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31882 
      return
31883 
    iprot.readStructBegin()
31884 
    while True:
31885 
      (fname, ftype, fid) = iprot.readFieldBegin()
31886 
      if ftype == TType.STOP:
31887 
        break
31888 
      if fid == 0:
31889 
        if ftype == TType.LIST:
31890 
          self.success = []
31891 
          (_etype740, _size737) = iprot.readListBegin()
31892 
          for _i741 in xrange(_size737):
31893 
            _elem742 = RechargeTransaction()
31894 
            _elem742.read(iprot)
31895 
            self.success.append(_elem742)
31896 
          iprot.readListEnd()
31897 
        else:
31898 
          iprot.skip(ftype)
31899 
      else:
31900 
        iprot.skip(ftype)
31901 
      iprot.readFieldEnd()
31902 
    iprot.readStructEnd()
31903 
 
31904 
  def write(self, oprot):
31905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31907 
      return
31908 
    oprot.writeStructBegin('getRechargeTransactions_result')
31909 
    if self.success is not None:
31910 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31911 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31912 
      for iter743 in self.success:
31913 
        iter743.write(oprot)
31914 
      oprot.writeListEnd()
31915 
      oprot.writeFieldEnd()
31916 
    oprot.writeFieldStop()
31917 
    oprot.writeStructEnd()
31918 
 
31919 
  def validate(self):
31920 
    return
31921 
 
31922 
 
31923 
  def __repr__(self):
31924 
    L = ['%s=%r' % (key, value)
31925 
      for key, value in self.__dict__.iteritems()]
31926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31927 
 
31928 
  def __eq__(self, other):
31929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31930 
 
31931 
  def __ne__(self, other):
31932 
    return not (self == other)
31933 
 
7151 amit.gupta 31934 
class getRechargeTrans_args:
31935 
  """
31936 
  Attributes:
31937 
   - storeId
31938 
   - startDate
31939 
   - endDate
31940 
   - status
31941 
  """
31942 
 
31943 
  thrift_spec = (
31944 
    None, # 0
31945 
    (1, TType.I64, 'storeId', None, None, ), # 1
31946 
    (2, TType.I64, 'startDate', None, None, ), # 2
31947 
    (3, TType.I64, 'endDate', None, None, ), # 3
31948 
    (4, TType.I32, 'status', None, None, ), # 4
31949 
  )
31950 
 
31951 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31952 
    self.storeId = storeId
31953 
    self.startDate = startDate
31954 
    self.endDate = endDate
31955 
    self.status = status
31956 
 
31957 
  def read(self, iprot):
31958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31960 
      return
31961 
    iprot.readStructBegin()
31962 
    while True:
31963 
      (fname, ftype, fid) = iprot.readFieldBegin()
31964 
      if ftype == TType.STOP:
31965 
        break
31966 
      if fid == 1:
31967 
        if ftype == TType.I64:
31968 
          self.storeId = iprot.readI64();
31969 
        else:
31970 
          iprot.skip(ftype)
31971 
      elif fid == 2:
31972 
        if ftype == TType.I64:
31973 
          self.startDate = iprot.readI64();
31974 
        else:
31975 
          iprot.skip(ftype)
31976 
      elif fid == 3:
31977 
        if ftype == TType.I64:
31978 
          self.endDate = iprot.readI64();
31979 
        else:
31980 
          iprot.skip(ftype)
31981 
      elif fid == 4:
31982 
        if ftype == TType.I32:
31983 
          self.status = iprot.readI32();
31984 
        else:
31985 
          iprot.skip(ftype)
31986 
      else:
31987 
        iprot.skip(ftype)
31988 
      iprot.readFieldEnd()
31989 
    iprot.readStructEnd()
31990 
 
31991 
  def write(self, oprot):
31992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31994 
      return
31995 
    oprot.writeStructBegin('getRechargeTrans_args')
31996 
    if self.storeId is not None:
31997 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31998 
      oprot.writeI64(self.storeId)
31999 
      oprot.writeFieldEnd()
32000 
    if self.startDate is not None:
32001 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
32002 
      oprot.writeI64(self.startDate)
32003 
      oprot.writeFieldEnd()
32004 
    if self.endDate is not None:
32005 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
32006 
      oprot.writeI64(self.endDate)
32007 
      oprot.writeFieldEnd()
32008 
    if self.status is not None:
32009 
      oprot.writeFieldBegin('status', TType.I32, 4)
32010 
      oprot.writeI32(self.status)
32011 
      oprot.writeFieldEnd()
32012 
    oprot.writeFieldStop()
32013 
    oprot.writeStructEnd()
32014 
 
32015 
  def validate(self):
32016 
    return
32017 
 
32018 
 
32019 
  def __repr__(self):
32020 
    L = ['%s=%r' % (key, value)
32021 
      for key, value in self.__dict__.iteritems()]
32022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32023 
 
32024 
  def __eq__(self, other):
32025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32026 
 
32027 
  def __ne__(self, other):
32028 
    return not (self == other)
32029 
 
32030 
class getRechargeTrans_result:
32031 
  """
32032 
  Attributes:
32033 
   - success
32034 
  """
32035 
 
32036 
  thrift_spec = (
32037 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32038 
  )
32039 
 
32040 
  def __init__(self, success=None,):
32041 
    self.success = success
32042 
 
32043 
  def read(self, iprot):
32044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32046 
      return
32047 
    iprot.readStructBegin()
32048 
    while True:
32049 
      (fname, ftype, fid) = iprot.readFieldBegin()
32050 
      if ftype == TType.STOP:
32051 
        break
32052 
      if fid == 0:
32053 
        if ftype == TType.LIST:
32054 
          self.success = []
32055 
          (_etype747, _size744) = iprot.readListBegin()
32056 
          for _i748 in xrange(_size744):
32057 
            _elem749 = RechargeTransaction()
32058 
            _elem749.read(iprot)
32059 
            self.success.append(_elem749)
32060 
          iprot.readListEnd()
32061 
        else:
32062 
          iprot.skip(ftype)
32063 
      else:
32064 
        iprot.skip(ftype)
32065 
      iprot.readFieldEnd()
32066 
    iprot.readStructEnd()
32067 
 
32068 
  def write(self, oprot):
32069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32071 
      return
32072 
    oprot.writeStructBegin('getRechargeTrans_result')
32073 
    if self.success is not None:
32074 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32075 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32076 
      for iter750 in self.success:
32077 
        iter750.write(oprot)
32078 
      oprot.writeListEnd()
32079 
      oprot.writeFieldEnd()
32080 
    oprot.writeFieldStop()
32081 
    oprot.writeStructEnd()
32082 
 
32083 
  def validate(self):
32084 
    return
32085 
 
32086 
 
32087 
  def __repr__(self):
32088 
    L = ['%s=%r' % (key, value)
32089 
      for key, value in self.__dict__.iteritems()]
32090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32091 
 
32092 
  def __eq__(self, other):
32093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32094 
 
32095 
  def __ne__(self, other):
32096 
    return not (self == other)
32097 
 
7080 anupam.sin 32098 
class getRechargeTransaction_args:
32099 
  """
32100 
  Attributes:
32101 
   - rechargeId
32102 
  """
32103 
 
32104 
  thrift_spec = (
32105 
    None, # 0
32106 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
32107 
  )
32108 
 
32109 
  def __init__(self, rechargeId=None,):
32110 
    self.rechargeId = rechargeId
32111 
 
32112 
  def read(self, iprot):
32113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32115 
      return
32116 
    iprot.readStructBegin()
32117 
    while True:
32118 
      (fname, ftype, fid) = iprot.readFieldBegin()
32119 
      if ftype == TType.STOP:
32120 
        break
32121 
      if fid == 1:
32122 
        if ftype == TType.I64:
32123 
          self.rechargeId = iprot.readI64();
32124 
        else:
32125 
          iprot.skip(ftype)
32126 
      else:
32127 
        iprot.skip(ftype)
32128 
      iprot.readFieldEnd()
32129 
    iprot.readStructEnd()
32130 
 
32131 
  def write(self, oprot):
32132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32134 
      return
32135 
    oprot.writeStructBegin('getRechargeTransaction_args')
32136 
    if self.rechargeId is not None:
32137 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
32138 
      oprot.writeI64(self.rechargeId)
32139 
      oprot.writeFieldEnd()
32140 
    oprot.writeFieldStop()
32141 
    oprot.writeStructEnd()
32142 
 
32143 
  def validate(self):
32144 
    return
32145 
 
32146 
 
32147 
  def __repr__(self):
32148 
    L = ['%s=%r' % (key, value)
32149 
      for key, value in self.__dict__.iteritems()]
32150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32151 
 
32152 
  def __eq__(self, other):
32153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32154 
 
32155 
  def __ne__(self, other):
32156 
    return not (self == other)
32157 
 
32158 
class getRechargeTransaction_result:
32159 
  """
32160 
  Attributes:
32161 
   - success
32162 
  """
32163 
 
32164 
  thrift_spec = (
32165 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
32166 
  )
32167 
 
32168 
  def __init__(self, success=None,):
32169 
    self.success = success
32170 
 
32171 
  def read(self, iprot):
32172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32174 
      return
32175 
    iprot.readStructBegin()
32176 
    while True:
32177 
      (fname, ftype, fid) = iprot.readFieldBegin()
32178 
      if ftype == TType.STOP:
32179 
        break
32180 
      if fid == 0:
32181 
        if ftype == TType.STRUCT:
32182 
          self.success = RechargeTransaction()
32183 
          self.success.read(iprot)
32184 
        else:
32185 
          iprot.skip(ftype)
32186 
      else:
32187 
        iprot.skip(ftype)
32188 
      iprot.readFieldEnd()
32189 
    iprot.readStructEnd()
32190 
 
32191 
  def write(self, oprot):
32192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32194 
      return
32195 
    oprot.writeStructBegin('getRechargeTransaction_result')
32196 
    if self.success is not None:
32197 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32198 
      self.success.write(oprot)
32199 
      oprot.writeFieldEnd()
32200 
    oprot.writeFieldStop()
32201 
    oprot.writeStructEnd()
32202 
 
32203 
  def validate(self):
32204 
    return
32205 
 
32206 
 
32207 
  def __repr__(self):
32208 
    L = ['%s=%r' % (key, value)
32209 
      for key, value in self.__dict__.iteritems()]
32210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32211 
 
32212 
  def __eq__(self, other):
32213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32214 
 
32215 
  def __ne__(self, other):
32216 
    return not (self == other)
32217 
 
32218 
class getFRCs_args:
32219 
  """
32220 
  Attributes:
32221 
   - circleId
32222 
   - operatorId
32223 
  """
32224 
 
32225 
  thrift_spec = (
32226 
    None, # 0
32227 
    (1, TType.I64, 'circleId', None, None, ), # 1
32228 
    (2, TType.I64, 'operatorId', None, None, ), # 2
32229 
  )
32230 
 
32231 
  def __init__(self, circleId=None, operatorId=None,):
32232 
    self.circleId = circleId
32233 
    self.operatorId = operatorId
32234 
 
32235 
  def read(self, iprot):
32236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32238 
      return
32239 
    iprot.readStructBegin()
32240 
    while True:
32241 
      (fname, ftype, fid) = iprot.readFieldBegin()
32242 
      if ftype == TType.STOP:
32243 
        break
32244 
      if fid == 1:
32245 
        if ftype == TType.I64:
32246 
          self.circleId = iprot.readI64();
32247 
        else:
32248 
          iprot.skip(ftype)
32249 
      elif fid == 2:
32250 
        if ftype == TType.I64:
32251 
          self.operatorId = iprot.readI64();
32252 
        else:
32253 
          iprot.skip(ftype)
32254 
      else:
32255 
        iprot.skip(ftype)
32256 
      iprot.readFieldEnd()
32257 
    iprot.readStructEnd()
32258 
 
32259 
  def write(self, oprot):
32260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32262 
      return
32263 
    oprot.writeStructBegin('getFRCs_args')
32264 
    if self.circleId is not None:
32265 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
32266 
      oprot.writeI64(self.circleId)
32267 
      oprot.writeFieldEnd()
32268 
    if self.operatorId is not None:
32269 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
32270 
      oprot.writeI64(self.operatorId)
32271 
      oprot.writeFieldEnd()
32272 
    oprot.writeFieldStop()
32273 
    oprot.writeStructEnd()
32274 
 
32275 
  def validate(self):
32276 
    return
32277 
 
32278 
 
32279 
  def __repr__(self):
32280 
    L = ['%s=%r' % (key, value)
32281 
      for key, value in self.__dict__.iteritems()]
32282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32283 
 
32284 
  def __eq__(self, other):
32285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32286 
 
32287 
  def __ne__(self, other):
32288 
    return not (self == other)
32289 
 
32290 
class getFRCs_result:
32291 
  """
32292 
  Attributes:
32293 
   - success
32294 
  """
32295 
 
32296 
  thrift_spec = (
32297 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
32298 
  )
32299 
 
32300 
  def __init__(self, success=None,):
32301 
    self.success = success
32302 
 
32303 
  def read(self, iprot):
32304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32306 
      return
32307 
    iprot.readStructBegin()
32308 
    while True:
32309 
      (fname, ftype, fid) = iprot.readFieldBegin()
32310 
      if ftype == TType.STOP:
32311 
        break
32312 
      if fid == 0:
32313 
        if ftype == TType.LIST:
32314 
          self.success = []
7151 amit.gupta 32315 
          (_etype754, _size751) = iprot.readListBegin()
32316 
          for _i755 in xrange(_size751):
32317 
            _elem756 = FRC()
32318 
            _elem756.read(iprot)
32319 
            self.success.append(_elem756)
7080 anupam.sin 32320 
          iprot.readListEnd()
32321 
        else:
32322 
          iprot.skip(ftype)
32323 
      else:
32324 
        iprot.skip(ftype)
32325 
      iprot.readFieldEnd()
32326 
    iprot.readStructEnd()
32327 
 
32328 
  def write(self, oprot):
32329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32331 
      return
32332 
    oprot.writeStructBegin('getFRCs_result')
32333 
    if self.success is not None:
32334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 32336 
      for iter757 in self.success:
32337 
        iter757.write(oprot)
7080 anupam.sin 32338 
      oprot.writeListEnd()
32339 
      oprot.writeFieldEnd()
32340 
    oprot.writeFieldStop()
32341 
    oprot.writeStructEnd()
32342 
 
32343 
  def validate(self):
32344 
    return
32345 
 
32346 
 
32347 
  def __repr__(self):
32348 
    L = ['%s=%r' % (key, value)
32349 
      for key, value in self.__dict__.iteritems()]
32350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32351 
 
32352 
  def __eq__(self, other):
32353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32354 
 
32355 
  def __ne__(self, other):
32356 
    return not (self == other)
7096 anupam.sin 32357 
 
32358 
class getHotspotStore_args:
32359 
  """
32360 
  Attributes:
32361 
   - id
32362 
   - hotspotid
32363 
  """
32364 
 
32365 
  thrift_spec = (
32366 
    None, # 0
32367 
    (1, TType.I64, 'id', None, None, ), # 1
32368 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
32369 
  )
32370 
 
32371 
  def __init__(self, id=None, hotspotid=None,):
32372 
    self.id = id
32373 
    self.hotspotid = hotspotid
32374 
 
32375 
  def read(self, iprot):
32376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32378 
      return
32379 
    iprot.readStructBegin()
32380 
    while True:
32381 
      (fname, ftype, fid) = iprot.readFieldBegin()
32382 
      if ftype == TType.STOP:
32383 
        break
32384 
      if fid == 1:
32385 
        if ftype == TType.I64:
32386 
          self.id = iprot.readI64();
32387 
        else:
32388 
          iprot.skip(ftype)
32389 
      elif fid == 2:
32390 
        if ftype == TType.STRING:
32391 
          self.hotspotid = iprot.readString();
32392 
        else:
32393 
          iprot.skip(ftype)
32394 
      else:
32395 
        iprot.skip(ftype)
32396 
      iprot.readFieldEnd()
32397 
    iprot.readStructEnd()
32398 
 
32399 
  def write(self, oprot):
32400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32402 
      return
32403 
    oprot.writeStructBegin('getHotspotStore_args')
32404 
    if self.id is not None:
32405 
      oprot.writeFieldBegin('id', TType.I64, 1)
32406 
      oprot.writeI64(self.id)
32407 
      oprot.writeFieldEnd()
32408 
    if self.hotspotid is not None:
32409 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
32410 
      oprot.writeString(self.hotspotid)
32411 
      oprot.writeFieldEnd()
32412 
    oprot.writeFieldStop()
32413 
    oprot.writeStructEnd()
32414 
 
32415 
  def validate(self):
32416 
    return
32417 
 
32418 
 
32419 
  def __repr__(self):
32420 
    L = ['%s=%r' % (key, value)
32421 
      for key, value in self.__dict__.iteritems()]
32422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32423 
 
32424 
  def __eq__(self, other):
32425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32426 
 
32427 
  def __ne__(self, other):
32428 
    return not (self == other)
32429 
 
32430 
class getHotspotStore_result:
32431 
  """
32432 
  Attributes:
32433 
   - success
32434 
  """
32435 
 
32436 
  thrift_spec = (
32437 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
32438 
  )
32439 
 
32440 
  def __init__(self, success=None,):
32441 
    self.success = success
32442 
 
32443 
  def read(self, iprot):
32444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32446 
      return
32447 
    iprot.readStructBegin()
32448 
    while True:
32449 
      (fname, ftype, fid) = iprot.readFieldBegin()
32450 
      if ftype == TType.STOP:
32451 
        break
32452 
      if fid == 0:
32453 
        if ftype == TType.STRUCT:
32454 
          self.success = HotspotStore()
32455 
          self.success.read(iprot)
32456 
        else:
32457 
          iprot.skip(ftype)
32458 
      else:
32459 
        iprot.skip(ftype)
32460 
      iprot.readFieldEnd()
32461 
    iprot.readStructEnd()
32462 
 
32463 
  def write(self, oprot):
32464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32466 
      return
32467 
    oprot.writeStructBegin('getHotspotStore_result')
32468 
    if self.success is not None:
32469 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32470 
      self.success.write(oprot)
32471 
      oprot.writeFieldEnd()
32472 
    oprot.writeFieldStop()
32473 
    oprot.writeStructEnd()
32474 
 
32475 
  def validate(self):
32476 
    return
32477 
 
32478 
 
32479 
  def __repr__(self):
32480 
    L = ['%s=%r' % (key, value)
32481 
      for key, value in self.__dict__.iteritems()]
32482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32483 
 
32484 
  def __eq__(self, other):
32485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32486 
 
32487 
  def __ne__(self, other):
32488 
    return not (self == other)
32489 
 
32490 
class getTelecomCircle_args:
32491 
  """
32492 
  Attributes:
32493 
   - id
32494 
   - code
32495 
  """
32496 
 
32497 
  thrift_spec = (
32498 
    None, # 0
32499 
    (1, TType.I64, 'id', None, None, ), # 1
32500 
    (2, TType.STRING, 'code', None, None, ), # 2
32501 
  )
32502 
 
32503 
  def __init__(self, id=None, code=None,):
32504 
    self.id = id
32505 
    self.code = code
32506 
 
32507 
  def read(self, iprot):
32508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32510 
      return
32511 
    iprot.readStructBegin()
32512 
    while True:
32513 
      (fname, ftype, fid) = iprot.readFieldBegin()
32514 
      if ftype == TType.STOP:
32515 
        break
32516 
      if fid == 1:
32517 
        if ftype == TType.I64:
32518 
          self.id = iprot.readI64();
32519 
        else:
32520 
          iprot.skip(ftype)
32521 
      elif fid == 2:
32522 
        if ftype == TType.STRING:
32523 
          self.code = iprot.readString();
32524 
        else:
32525 
          iprot.skip(ftype)
32526 
      else:
32527 
        iprot.skip(ftype)
32528 
      iprot.readFieldEnd()
32529 
    iprot.readStructEnd()
32530 
 
32531 
  def write(self, oprot):
32532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32534 
      return
32535 
    oprot.writeStructBegin('getTelecomCircle_args')
32536 
    if self.id is not None:
32537 
      oprot.writeFieldBegin('id', TType.I64, 1)
32538 
      oprot.writeI64(self.id)
32539 
      oprot.writeFieldEnd()
32540 
    if self.code is not None:
32541 
      oprot.writeFieldBegin('code', TType.STRING, 2)
32542 
      oprot.writeString(self.code)
32543 
      oprot.writeFieldEnd()
32544 
    oprot.writeFieldStop()
32545 
    oprot.writeStructEnd()
32546 
 
32547 
  def validate(self):
32548 
    return
32549 
 
32550 
 
32551 
  def __repr__(self):
32552 
    L = ['%s=%r' % (key, value)
32553 
      for key, value in self.__dict__.iteritems()]
32554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32555 
 
32556 
  def __eq__(self, other):
32557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32558 
 
32559 
  def __ne__(self, other):
32560 
    return not (self == other)
32561 
 
32562 
class getTelecomCircle_result:
32563 
  """
32564 
  Attributes:
32565 
   - success
32566 
  """
32567 
 
32568 
  thrift_spec = (
32569 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
32570 
  )
32571 
 
32572 
  def __init__(self, success=None,):
32573 
    self.success = success
32574 
 
32575 
  def read(self, iprot):
32576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32578 
      return
32579 
    iprot.readStructBegin()
32580 
    while True:
32581 
      (fname, ftype, fid) = iprot.readFieldBegin()
32582 
      if ftype == TType.STOP:
32583 
        break
32584 
      if fid == 0:
32585 
        if ftype == TType.STRUCT:
32586 
          self.success = TelecomCircle()
32587 
          self.success.read(iprot)
32588 
        else:
32589 
          iprot.skip(ftype)
32590 
      else:
32591 
        iprot.skip(ftype)
32592 
      iprot.readFieldEnd()
32593 
    iprot.readStructEnd()
32594 
 
32595 
  def write(self, oprot):
32596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32598 
      return
32599 
    oprot.writeStructBegin('getTelecomCircle_result')
32600 
    if self.success is not None:
32601 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32602 
      self.success.write(oprot)
32603 
      oprot.writeFieldEnd()
32604 
    oprot.writeFieldStop()
32605 
    oprot.writeStructEnd()
32606 
 
32607 
  def validate(self):
32608 
    return
32609 
 
32610 
 
32611 
  def __repr__(self):
32612 
    L = ['%s=%r' % (key, value)
32613 
      for key, value in self.__dict__.iteritems()]
32614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32615 
 
32616 
  def __eq__(self, other):
32617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32618 
 
32619 
  def __ne__(self, other):
32620 
    return not (self == other)
7109 anupam.sin 32621 
 
32622 
class retrieveHotspotRechargeInvoice_args:
32623 
  """
32624 
  Attributes:
32625 
   - rechargeId
32626 
  """
32627 
 
32628 
  thrift_spec = (
32629 
    None, # 0
32630 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
32631 
  )
32632 
 
32633 
  def __init__(self, rechargeId=None,):
32634 
    self.rechargeId = rechargeId
32635 
 
32636 
  def read(self, iprot):
32637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32639 
      return
32640 
    iprot.readStructBegin()
32641 
    while True:
32642 
      (fname, ftype, fid) = iprot.readFieldBegin()
32643 
      if ftype == TType.STOP:
32644 
        break
32645 
      if fid == 1:
32646 
        if ftype == TType.I64:
32647 
          self.rechargeId = iprot.readI64();
32648 
        else:
32649 
          iprot.skip(ftype)
32650 
      else:
32651 
        iprot.skip(ftype)
32652 
      iprot.readFieldEnd()
32653 
    iprot.readStructEnd()
32654 
 
32655 
  def write(self, oprot):
32656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32658 
      return
32659 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
32660 
    if self.rechargeId is not None:
32661 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
32662 
      oprot.writeI64(self.rechargeId)
32663 
      oprot.writeFieldEnd()
32664 
    oprot.writeFieldStop()
32665 
    oprot.writeStructEnd()
32666 
 
32667 
  def validate(self):
32668 
    return
32669 
 
32670 
 
32671 
  def __repr__(self):
32672 
    L = ['%s=%r' % (key, value)
32673 
      for key, value in self.__dict__.iteritems()]
32674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32675 
 
32676 
  def __eq__(self, other):
32677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32678 
 
32679 
  def __ne__(self, other):
32680 
    return not (self == other)
32681 
 
32682 
class retrieveHotspotRechargeInvoice_result:
32683 
  """
32684 
  Attributes:
32685 
   - success
32686 
  """
32687 
 
32688 
  thrift_spec = (
32689 
    (0, TType.STRING, 'success', None, None, ), # 0
32690 
  )
32691 
 
32692 
  def __init__(self, success=None,):
32693 
    self.success = success
32694 
 
32695 
  def read(self, iprot):
32696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32698 
      return
32699 
    iprot.readStructBegin()
32700 
    while True:
32701 
      (fname, ftype, fid) = iprot.readFieldBegin()
32702 
      if ftype == TType.STOP:
32703 
        break
32704 
      if fid == 0:
32705 
        if ftype == TType.STRING:
32706 
          self.success = iprot.readString();
32707 
        else:
32708 
          iprot.skip(ftype)
32709 
      else:
32710 
        iprot.skip(ftype)
32711 
      iprot.readFieldEnd()
32712 
    iprot.readStructEnd()
32713 
 
32714 
  def write(self, oprot):
32715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32717 
      return
32718 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
32719 
    if self.success is not None:
32720 
      oprot.writeFieldBegin('success', TType.STRING, 0)
32721 
      oprot.writeString(self.success)
32722 
      oprot.writeFieldEnd()
32723 
    oprot.writeFieldStop()
32724 
    oprot.writeStructEnd()
32725 
 
32726 
  def validate(self):
32727 
    return
32728 
 
32729 
 
32730 
  def __repr__(self):
32731 
    L = ['%s=%r' % (key, value)
32732 
      for key, value in self.__dict__.iteritems()]
32733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32734 
 
32735 
  def __eq__(self, other):
32736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32737 
 
32738 
  def __ne__(self, other):
32739 
    return not (self == other)
7169 anupam.sin 32740 
 
7190 amar.kumar 32741 
class splitFreebieOrder_args:
32742 
  """
32743 
  Attributes:
32744 
   - orderId
32745 
   - splitReason
32746 
   - shippingDate
32747 
  """
32748 
 
32749 
  thrift_spec = (
32750 
    None, # 0
32751 
    (1, TType.I64, 'orderId', None, None, ), # 1
32752 
    (2, TType.STRING, 'splitReason', None, None, ), # 2
32753 
    (3, TType.I64, 'shippingDate', None, None, ), # 3
32754 
  )
32755 
 
32756 
  def __init__(self, orderId=None, splitReason=None, shippingDate=None,):
32757 
    self.orderId = orderId
32758 
    self.splitReason = splitReason
32759 
    self.shippingDate = shippingDate
32760 
 
32761 
  def read(self, iprot):
32762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32764 
      return
32765 
    iprot.readStructBegin()
32766 
    while True:
32767 
      (fname, ftype, fid) = iprot.readFieldBegin()
32768 
      if ftype == TType.STOP:
32769 
        break
32770 
      if fid == 1:
32771 
        if ftype == TType.I64:
32772 
          self.orderId = iprot.readI64();
32773 
        else:
32774 
          iprot.skip(ftype)
32775 
      elif fid == 2:
32776 
        if ftype == TType.STRING:
32777 
          self.splitReason = iprot.readString();
32778 
        else:
32779 
          iprot.skip(ftype)
32780 
      elif fid == 3:
32781 
        if ftype == TType.I64:
32782 
          self.shippingDate = iprot.readI64();
32783 
        else:
32784 
          iprot.skip(ftype)
32785 
      else:
32786 
        iprot.skip(ftype)
32787 
      iprot.readFieldEnd()
32788 
    iprot.readStructEnd()
32789 
 
32790 
  def write(self, oprot):
32791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32793 
      return
32794 
    oprot.writeStructBegin('splitFreebieOrder_args')
32795 
    if self.orderId is not None:
32796 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
32797 
      oprot.writeI64(self.orderId)
32798 
      oprot.writeFieldEnd()
32799 
    if self.splitReason is not None:
32800 
      oprot.writeFieldBegin('splitReason', TType.STRING, 2)
32801 
      oprot.writeString(self.splitReason)
32802 
      oprot.writeFieldEnd()
32803 
    if self.shippingDate is not None:
32804 
      oprot.writeFieldBegin('shippingDate', TType.I64, 3)
32805 
      oprot.writeI64(self.shippingDate)
32806 
      oprot.writeFieldEnd()
32807 
    oprot.writeFieldStop()
32808 
    oprot.writeStructEnd()
32809 
 
32810 
  def validate(self):
32811 
    return
32812 
 
32813 
 
32814 
  def __repr__(self):
32815 
    L = ['%s=%r' % (key, value)
32816 
      for key, value in self.__dict__.iteritems()]
32817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32818 
 
32819 
  def __eq__(self, other):
32820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32821 
 
32822 
  def __ne__(self, other):
32823 
    return not (self == other)
32824 
 
32825 
class splitFreebieOrder_result:
32826 
  """
32827 
  Attributes:
32828 
   - success
32829 
  """
32830 
 
32831 
  thrift_spec = (
32832 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
32833 
  )
32834 
 
32835 
  def __init__(self, success=None,):
32836 
    self.success = success
32837 
 
32838 
  def read(self, iprot):
32839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32841 
      return
32842 
    iprot.readStructBegin()
32843 
    while True:
32844 
      (fname, ftype, fid) = iprot.readFieldBegin()
32845 
      if ftype == TType.STOP:
32846 
        break
32847 
      if fid == 0:
32848 
        if ftype == TType.STRUCT:
32849 
          self.success = Order()
32850 
          self.success.read(iprot)
32851 
        else:
32852 
          iprot.skip(ftype)
32853 
      else:
32854 
        iprot.skip(ftype)
32855 
      iprot.readFieldEnd()
32856 
    iprot.readStructEnd()
32857 
 
32858 
  def write(self, oprot):
32859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32861 
      return
32862 
    oprot.writeStructBegin('splitFreebieOrder_result')
32863 
    if self.success is not None:
32864 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32865 
      self.success.write(oprot)
32866 
      oprot.writeFieldEnd()
32867 
    oprot.writeFieldStop()
32868 
    oprot.writeStructEnd()
32869 
 
32870 
  def validate(self):
32871 
    return
32872 
 
32873 
 
32874 
  def __repr__(self):
32875 
    L = ['%s=%r' % (key, value)
32876 
      for key, value in self.__dict__.iteritems()]
32877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32878 
 
32879 
  def __eq__(self, other):
32880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32881 
 
32882 
  def __ne__(self, other):
32883 
    return not (self == other)
32884 
 
7169 anupam.sin 32885 
class getRechargeTransactionsByNumber_args:
32886 
  """
32887 
  Attributes:
32888 
   - number
7172 anupam.sin 32889 
   - storeId
7169 anupam.sin 32890 
  """
32891 
 
32892 
  thrift_spec = (
32893 
    None, # 0
32894 
    (1, TType.STRING, 'number', None, None, ), # 1
7172 anupam.sin 32895 
    (2, TType.I64, 'storeId', None, None, ), # 2
7169 anupam.sin 32896 
  )
32897 
 
7172 anupam.sin 32898 
  def __init__(self, number=None, storeId=None,):
7169 anupam.sin 32899 
    self.number = number
7172 anupam.sin 32900 
    self.storeId = storeId
7169 anupam.sin 32901 
 
32902 
  def read(self, iprot):
32903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32905 
      return
32906 
    iprot.readStructBegin()
32907 
    while True:
32908 
      (fname, ftype, fid) = iprot.readFieldBegin()
32909 
      if ftype == TType.STOP:
32910 
        break
32911 
      if fid == 1:
32912 
        if ftype == TType.STRING:
32913 
          self.number = iprot.readString();
32914 
        else:
32915 
          iprot.skip(ftype)
7172 anupam.sin 32916 
      elif fid == 2:
32917 
        if ftype == TType.I64:
32918 
          self.storeId = iprot.readI64();
32919 
        else:
32920 
          iprot.skip(ftype)
7169 anupam.sin 32921 
      else:
32922 
        iprot.skip(ftype)
32923 
      iprot.readFieldEnd()
32924 
    iprot.readStructEnd()
32925 
 
32926 
  def write(self, oprot):
32927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32929 
      return
32930 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_args')
32931 
    if self.number is not None:
32932 
      oprot.writeFieldBegin('number', TType.STRING, 1)
32933 
      oprot.writeString(self.number)
32934 
      oprot.writeFieldEnd()
7172 anupam.sin 32935 
    if self.storeId is not None:
32936 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
32937 
      oprot.writeI64(self.storeId)
32938 
      oprot.writeFieldEnd()
7169 anupam.sin 32939 
    oprot.writeFieldStop()
32940 
    oprot.writeStructEnd()
32941 
 
32942 
  def validate(self):
32943 
    return
32944 
 
32945 
 
32946 
  def __repr__(self):
32947 
    L = ['%s=%r' % (key, value)
32948 
      for key, value in self.__dict__.iteritems()]
32949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32950 
 
32951 
  def __eq__(self, other):
32952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32953 
 
32954 
  def __ne__(self, other):
32955 
    return not (self == other)
32956 
 
32957 
class getRechargeTransactionsByNumber_result:
32958 
  """
32959 
  Attributes:
32960 
   - success
32961 
  """
32962 
 
32963 
  thrift_spec = (
32964 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32965 
  )
32966 
 
32967 
  def __init__(self, success=None,):
32968 
    self.success = success
32969 
 
32970 
  def read(self, iprot):
32971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32973 
      return
32974 
    iprot.readStructBegin()
32975 
    while True:
32976 
      (fname, ftype, fid) = iprot.readFieldBegin()
32977 
      if ftype == TType.STOP:
32978 
        break
32979 
      if fid == 0:
32980 
        if ftype == TType.LIST:
32981 
          self.success = []
32982 
          (_etype761, _size758) = iprot.readListBegin()
32983 
          for _i762 in xrange(_size758):
32984 
            _elem763 = RechargeTransaction()
32985 
            _elem763.read(iprot)
32986 
            self.success.append(_elem763)
32987 
          iprot.readListEnd()
32988 
        else:
32989 
          iprot.skip(ftype)
32990 
      else:
32991 
        iprot.skip(ftype)
32992 
      iprot.readFieldEnd()
32993 
    iprot.readStructEnd()
32994 
 
32995 
  def write(self, oprot):
32996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32998 
      return
32999 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
33000 
    if self.success is not None:
33001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
33003 
      for iter764 in self.success:
33004 
        iter764.write(oprot)
33005 
      oprot.writeListEnd()
33006 
      oprot.writeFieldEnd()
33007 
    oprot.writeFieldStop()
33008 
    oprot.writeStructEnd()
33009 
 
33010 
  def validate(self):
33011 
    return
33012 
 
33013 
 
33014 
  def __repr__(self):
33015 
    L = ['%s=%r' % (key, value)
33016 
      for key, value in self.__dict__.iteritems()]
33017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33018 
 
33019 
  def __eq__(self, other):
33020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33021 
 
33022 
  def __ne__(self, other):
33023 
    return not (self == other)
33024 
 
33025 
class updateHotspotStorePassword_args:
33026 
  """
33027 
  Attributes:
33028 
   - storeId
33029 
   - password
33030 
  """
33031 
 
33032 
  thrift_spec = (
33033 
    None, # 0
33034 
    (1, TType.I64, 'storeId', None, None, ), # 1
33035 
    (2, TType.STRING, 'password', None, None, ), # 2
33036 
  )
33037 
 
33038 
  def __init__(self, storeId=None, password=None,):
33039 
    self.storeId = storeId
33040 
    self.password = password
33041 
 
33042 
  def read(self, iprot):
33043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33045 
      return
33046 
    iprot.readStructBegin()
33047 
    while True:
33048 
      (fname, ftype, fid) = iprot.readFieldBegin()
33049 
      if ftype == TType.STOP:
33050 
        break
33051 
      if fid == 1:
33052 
        if ftype == TType.I64:
33053 
          self.storeId = iprot.readI64();
33054 
        else:
33055 
          iprot.skip(ftype)
33056 
      elif fid == 2:
33057 
        if ftype == TType.STRING:
33058 
          self.password = iprot.readString();
33059 
        else:
33060 
          iprot.skip(ftype)
33061 
      else:
33062 
        iprot.skip(ftype)
33063 
      iprot.readFieldEnd()
33064 
    iprot.readStructEnd()
33065 
 
33066 
  def write(self, oprot):
33067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33069 
      return
33070 
    oprot.writeStructBegin('updateHotspotStorePassword_args')
33071 
    if self.storeId is not None:
33072 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
33073 
      oprot.writeI64(self.storeId)
33074 
      oprot.writeFieldEnd()
33075 
    if self.password is not None:
33076 
      oprot.writeFieldBegin('password', TType.STRING, 2)
33077 
      oprot.writeString(self.password)
33078 
      oprot.writeFieldEnd()
33079 
    oprot.writeFieldStop()
33080 
    oprot.writeStructEnd()
33081 
 
33082 
  def validate(self):
33083 
    return
33084 
 
33085 
 
33086 
  def __repr__(self):
33087 
    L = ['%s=%r' % (key, value)
33088 
      for key, value in self.__dict__.iteritems()]
33089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33090 
 
33091 
  def __eq__(self, other):
33092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33093 
 
33094 
  def __ne__(self, other):
33095 
    return not (self == other)
33096 
 
33097 
class updateHotspotStorePassword_result:
33098 
  """
33099 
  Attributes:
33100 
   - success
33101 
  """
33102 
 
33103 
  thrift_spec = (
33104 
    (0, TType.BOOL, 'success', None, None, ), # 0
33105 
  )
33106 
 
33107 
  def __init__(self, success=None,):
33108 
    self.success = success
33109 
 
33110 
  def read(self, iprot):
33111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33113 
      return
33114 
    iprot.readStructBegin()
33115 
    while True:
33116 
      (fname, ftype, fid) = iprot.readFieldBegin()
33117 
      if ftype == TType.STOP:
33118 
        break
33119 
      if fid == 0:
33120 
        if ftype == TType.BOOL:
33121 
          self.success = iprot.readBool();
33122 
        else:
33123 
          iprot.skip(ftype)
33124 
      else:
33125 
        iprot.skip(ftype)
33126 
      iprot.readFieldEnd()
33127 
    iprot.readStructEnd()
33128 
 
33129 
  def write(self, oprot):
33130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33132 
      return
33133 
    oprot.writeStructBegin('updateHotspotStorePassword_result')
33134 
    if self.success is not None:
33135 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
33136 
      oprot.writeBool(self.success)
33137 
      oprot.writeFieldEnd()
33138 
    oprot.writeFieldStop()
33139 
    oprot.writeStructEnd()
33140 
 
33141 
  def validate(self):
33142 
    return
33143 
 
33144 
 
33145 
  def __repr__(self):
33146 
    L = ['%s=%r' % (key, value)
33147 
      for key, value in self.__dict__.iteritems()]
33148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33149 
 
33150 
  def __eq__(self, other):
33151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33152 
 
33153 
  def __ne__(self, other):
33154 
    return not (self == other)
7263 anupam.sin 33155 
 
7285 rajveer 33156 
class topupCompanyWallet_args:
7263 anupam.sin 33157 
  """
33158 
  Attributes:
7285 rajveer 33159 
   - companyId
33160 
   - amount
7263 anupam.sin 33161 
  """
33162 
 
33163 
  thrift_spec = (
33164 
    None, # 0
7285 rajveer 33165 
    (1, TType.I64, 'companyId', None, None, ), # 1
33166 
    (2, TType.I64, 'amount', None, None, ), # 2
7263 anupam.sin 33167 
  )
33168 
 
7285 rajveer 33169 
  def __init__(self, companyId=None, amount=None,):
33170 
    self.companyId = companyId
33171 
    self.amount = amount
7263 anupam.sin 33172 
 
33173 
  def read(self, iprot):
33174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33176 
      return
33177 
    iprot.readStructBegin()
33178 
    while True:
33179 
      (fname, ftype, fid) = iprot.readFieldBegin()
33180 
      if ftype == TType.STOP:
33181 
        break
33182 
      if fid == 1:
33183 
        if ftype == TType.I64:
7285 rajveer 33184 
          self.companyId = iprot.readI64();
7263 anupam.sin 33185 
        else:
33186 
          iprot.skip(ftype)
7285 rajveer 33187 
      elif fid == 2:
33188 
        if ftype == TType.I64:
33189 
          self.amount = iprot.readI64();
33190 
        else:
33191 
          iprot.skip(ftype)
7263 anupam.sin 33192 
      else:
33193 
        iprot.skip(ftype)
33194 
      iprot.readFieldEnd()
33195 
    iprot.readStructEnd()
33196 
 
33197 
  def write(self, oprot):
33198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33200 
      return
7285 rajveer 33201 
    oprot.writeStructBegin('topupCompanyWallet_args')
33202 
    if self.companyId is not None:
33203 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
33204 
      oprot.writeI64(self.companyId)
7263 anupam.sin 33205 
      oprot.writeFieldEnd()
7285 rajveer 33206 
    if self.amount is not None:
33207 
      oprot.writeFieldBegin('amount', TType.I64, 2)
33208 
      oprot.writeI64(self.amount)
33209 
      oprot.writeFieldEnd()
7263 anupam.sin 33210 
    oprot.writeFieldStop()
33211 
    oprot.writeStructEnd()
33212 
 
33213 
  def validate(self):
33214 
    return
33215 
 
33216 
 
33217 
  def __repr__(self):
33218 
    L = ['%s=%r' % (key, value)
33219 
      for key, value in self.__dict__.iteritems()]
33220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33221 
 
33222 
  def __eq__(self, other):
33223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33224 
 
33225 
  def __ne__(self, other):
33226 
    return not (self == other)
33227 
 
7285 rajveer 33228 
class topupCompanyWallet_result:
7263 anupam.sin 33229 
  """
33230 
  Attributes:
33231 
   - success
33232 
  """
33233 
 
33234 
  thrift_spec = (
7285 rajveer 33235 
    (0, TType.I64, 'success', None, None, ), # 0
7263 anupam.sin 33236 
  )
33237 
 
33238 
  def __init__(self, success=None,):
33239 
    self.success = success
33240 
 
33241 
  def read(self, iprot):
33242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33244 
      return
33245 
    iprot.readStructBegin()
33246 
    while True:
33247 
      (fname, ftype, fid) = iprot.readFieldBegin()
33248 
      if ftype == TType.STOP:
33249 
        break
33250 
      if fid == 0:
7285 rajveer 33251 
        if ftype == TType.I64:
33252 
          self.success = iprot.readI64();
7263 anupam.sin 33253 
        else:
33254 
          iprot.skip(ftype)
33255 
      else:
33256 
        iprot.skip(ftype)
33257 
      iprot.readFieldEnd()
33258 
    iprot.readStructEnd()
33259 
 
33260 
  def write(self, oprot):
33261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33263 
      return
7285 rajveer 33264 
    oprot.writeStructBegin('topupCompanyWallet_result')
7263 anupam.sin 33265 
    if self.success is not None:
7285 rajveer 33266 
      oprot.writeFieldBegin('success', TType.I64, 0)
33267 
      oprot.writeI64(self.success)
7263 anupam.sin 33268 
      oprot.writeFieldEnd()
33269 
    oprot.writeFieldStop()
33270 
    oprot.writeStructEnd()
33271 
 
33272 
  def validate(self):
33273 
    return
33274 
 
33275 
 
33276 
  def __repr__(self):
33277 
    L = ['%s=%r' % (key, value)
33278 
      for key, value in self.__dict__.iteritems()]
33279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33280 
 
33281 
  def __eq__(self, other):
33282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33283 
 
33284 
  def __ne__(self, other):
33285 
    return not (self == other)
7267 anupam.sin 33286 
 
7285 rajveer 33287 
class getWalletBalanceForCompany_args:
33288 
  """
33289 
  Attributes:
33290 
   - companyId
33291 
  """
7267 anupam.sin 33292 
 
33293 
  thrift_spec = (
7285 rajveer 33294 
    None, # 0
33295 
    (1, TType.I64, 'companyId', None, None, ), # 1
7267 anupam.sin 33296 
  )
33297 
 
7285 rajveer 33298 
  def __init__(self, companyId=None,):
33299 
    self.companyId = companyId
33300 
 
7267 anupam.sin 33301 
  def read(self, iprot):
33302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33304 
      return
33305 
    iprot.readStructBegin()
33306 
    while True:
33307 
      (fname, ftype, fid) = iprot.readFieldBegin()
33308 
      if ftype == TType.STOP:
33309 
        break
7285 rajveer 33310 
      if fid == 1:
33311 
        if ftype == TType.I64:
33312 
          self.companyId = iprot.readI64();
33313 
        else:
33314 
          iprot.skip(ftype)
7267 anupam.sin 33315 
      else:
33316 
        iprot.skip(ftype)
33317 
      iprot.readFieldEnd()
33318 
    iprot.readStructEnd()
33319 
 
33320 
  def write(self, oprot):
33321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33323 
      return
7285 rajveer 33324 
    oprot.writeStructBegin('getWalletBalanceForCompany_args')
33325 
    if self.companyId is not None:
33326 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
33327 
      oprot.writeI64(self.companyId)
33328 
      oprot.writeFieldEnd()
7267 anupam.sin 33329 
    oprot.writeFieldStop()
33330 
    oprot.writeStructEnd()
33331 
 
33332 
  def validate(self):
33333 
    return
33334 
 
33335 
 
33336 
  def __repr__(self):
33337 
    L = ['%s=%r' % (key, value)
33338 
      for key, value in self.__dict__.iteritems()]
33339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33340 
 
33341 
  def __eq__(self, other):
33342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33343 
 
33344 
  def __ne__(self, other):
33345 
    return not (self == other)
33346 
 
7285 rajveer 33347 
class getWalletBalanceForCompany_result:
7267 anupam.sin 33348 
  """
33349 
  Attributes:
33350 
   - success
33351 
  """
33352 
 
33353 
  thrift_spec = (
7285 rajveer 33354 
    (0, TType.I64, 'success', None, None, ), # 0
7267 anupam.sin 33355 
  )
33356 
 
33357 
  def __init__(self, success=None,):
33358 
    self.success = success
33359 
 
33360 
  def read(self, iprot):
33361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33363 
      return
33364 
    iprot.readStructBegin()
33365 
    while True:
33366 
      (fname, ftype, fid) = iprot.readFieldBegin()
33367 
      if ftype == TType.STOP:
33368 
        break
33369 
      if fid == 0:
7285 rajveer 33370 
        if ftype == TType.I64:
33371 
          self.success = iprot.readI64();
7267 anupam.sin 33372 
        else:
33373 
          iprot.skip(ftype)
33374 
      else:
33375 
        iprot.skip(ftype)
33376 
      iprot.readFieldEnd()
33377 
    iprot.readStructEnd()
33378 
 
33379 
  def write(self, oprot):
33380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33382 
      return
7285 rajveer 33383 
    oprot.writeStructBegin('getWalletBalanceForCompany_result')
7267 anupam.sin 33384 
    if self.success is not None:
7285 rajveer 33385 
      oprot.writeFieldBegin('success', TType.I64, 0)
33386 
      oprot.writeI64(self.success)
7267 anupam.sin 33387 
      oprot.writeFieldEnd()
33388 
    oprot.writeFieldStop()
33389 
    oprot.writeStructEnd()
33390 
 
33391 
  def validate(self):
33392 
    return
33393 
 
33394 
 
33395 
  def __repr__(self):
33396 
    L = ['%s=%r' % (key, value)
33397 
      for key, value in self.__dict__.iteritems()]
33398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33399 
 
33400 
  def __eq__(self, other):
33401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33402 
 
33403 
  def __ne__(self, other):
33404 
    return not (self == other)
33405 
 
7363 rajveer 33406 
class getSaholicRechargeBalance_args:
33407 
 
33408 
  thrift_spec = (
33409 
  )
33410 
 
33411 
  def read(self, iprot):
33412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33414 
      return
33415 
    iprot.readStructBegin()
33416 
    while True:
33417 
      (fname, ftype, fid) = iprot.readFieldBegin()
33418 
      if ftype == TType.STOP:
33419 
        break
33420 
      else:
33421 
        iprot.skip(ftype)
33422 
      iprot.readFieldEnd()
33423 
    iprot.readStructEnd()
33424 
 
33425 
  def write(self, oprot):
33426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33428 
      return
33429 
    oprot.writeStructBegin('getSaholicRechargeBalance_args')
33430 
    oprot.writeFieldStop()
33431 
    oprot.writeStructEnd()
33432 
 
33433 
  def validate(self):
33434 
    return
33435 
 
33436 
 
33437 
  def __repr__(self):
33438 
    L = ['%s=%r' % (key, value)
33439 
      for key, value in self.__dict__.iteritems()]
33440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33441 
 
33442 
  def __eq__(self, other):
33443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33444 
 
33445 
  def __ne__(self, other):
33446 
    return not (self == other)
33447 
 
33448 
class getSaholicRechargeBalance_result:
33449 
  """
33450 
  Attributes:
33451 
   - success
33452 
  """
33453 
 
33454 
  thrift_spec = (
33455 
    (0, TType.I64, 'success', None, None, ), # 0
33456 
  )
33457 
 
33458 
  def __init__(self, success=None,):
33459 
    self.success = success
33460 
 
33461 
  def read(self, iprot):
33462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33464 
      return
33465 
    iprot.readStructBegin()
33466 
    while True:
33467 
      (fname, ftype, fid) = iprot.readFieldBegin()
33468 
      if ftype == TType.STOP:
33469 
        break
33470 
      if fid == 0:
33471 
        if ftype == TType.I64:
33472 
          self.success = iprot.readI64();
33473 
        else:
33474 
          iprot.skip(ftype)
33475 
      else:
33476 
        iprot.skip(ftype)
33477 
      iprot.readFieldEnd()
33478 
    iprot.readStructEnd()
33479 
 
33480 
  def write(self, oprot):
33481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33483 
      return
33484 
    oprot.writeStructBegin('getSaholicRechargeBalance_result')
33485 
    if self.success is not None:
33486 
      oprot.writeFieldBegin('success', TType.I64, 0)
33487 
      oprot.writeI64(self.success)
33488 
      oprot.writeFieldEnd()
33489 
    oprot.writeFieldStop()
33490 
    oprot.writeStructEnd()
33491 
 
33492 
  def validate(self):
33493 
    return
33494 
 
33495 
 
33496 
  def __repr__(self):
33497 
    L = ['%s=%r' % (key, value)
33498 
      for key, value in self.__dict__.iteritems()]
33499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33500 
 
33501 
  def __eq__(self, other):
33502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33503 
 
33504 
  def __ne__(self, other):
33505 
    return not (self == other)
33506 
 
7285 rajveer 33507 
class getSourceDetail_args:
7267 anupam.sin 33508 
  """
33509 
  Attributes:
7285 rajveer 33510 
   - source
7267 anupam.sin 33511 
  """
33512 
 
33513 
  thrift_spec = (
33514 
    None, # 0
7285 rajveer 33515 
    (1, TType.I64, 'source', None, None, ), # 1
7267 anupam.sin 33516 
  )
33517 
 
7285 rajveer 33518 
  def __init__(self, source=None,):
33519 
    self.source = source
7267 anupam.sin 33520 
 
33521 
  def read(self, iprot):
33522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33524 
      return
33525 
    iprot.readStructBegin()
33526 
    while True:
33527 
      (fname, ftype, fid) = iprot.readFieldBegin()
33528 
      if ftype == TType.STOP:
33529 
        break
33530 
      if fid == 1:
7285 rajveer 33531 
        if ftype == TType.I64:
33532 
          self.source = iprot.readI64();
7267 anupam.sin 33533 
        else:
33534 
          iprot.skip(ftype)
33535 
      else:
33536 
        iprot.skip(ftype)
33537 
      iprot.readFieldEnd()
33538 
    iprot.readStructEnd()
33539 
 
33540 
  def write(self, oprot):
33541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33543 
      return
7285 rajveer 33544 
    oprot.writeStructBegin('getSourceDetail_args')
33545 
    if self.source is not None:
33546 
      oprot.writeFieldBegin('source', TType.I64, 1)
33547 
      oprot.writeI64(self.source)
7267 anupam.sin 33548 
      oprot.writeFieldEnd()
33549 
    oprot.writeFieldStop()
33550 
    oprot.writeStructEnd()
33551 
 
33552 
  def validate(self):
33553 
    return
33554 
 
33555 
 
33556 
  def __repr__(self):
33557 
    L = ['%s=%r' % (key, value)
33558 
      for key, value in self.__dict__.iteritems()]
33559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33560 
 
33561 
  def __eq__(self, other):
33562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33563 
 
33564 
  def __ne__(self, other):
33565 
    return not (self == other)
33566 
 
7285 rajveer 33567 
class getSourceDetail_result:
7267 anupam.sin 33568 
  """
33569 
  Attributes:
33570 
   - success
33571 
  """
33572 
 
33573 
  thrift_spec = (
7285 rajveer 33574 
    (0, TType.STRUCT, 'success', (SourceDetail, SourceDetail.thrift_spec), None, ), # 0
7267 anupam.sin 33575 
  )
33576 
 
33577 
  def __init__(self, success=None,):
33578 
    self.success = success
33579 
 
33580 
  def read(self, iprot):
33581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33583 
      return
33584 
    iprot.readStructBegin()
33585 
    while True:
33586 
      (fname, ftype, fid) = iprot.readFieldBegin()
33587 
      if ftype == TType.STOP:
33588 
        break
33589 
      if fid == 0:
7285 rajveer 33590 
        if ftype == TType.STRUCT:
33591 
          self.success = SourceDetail()
33592 
          self.success.read(iprot)
7267 anupam.sin 33593 
        else:
33594 
          iprot.skip(ftype)
33595 
      else:
33596 
        iprot.skip(ftype)
33597 
      iprot.readFieldEnd()
33598 
    iprot.readStructEnd()
33599 
 
33600 
  def write(self, oprot):
33601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33603 
      return
7285 rajveer 33604 
    oprot.writeStructBegin('getSourceDetail_result')
7267 anupam.sin 33605 
    if self.success is not None:
7285 rajveer 33606 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33607 
      self.success.write(oprot)
7267 anupam.sin 33608 
      oprot.writeFieldEnd()
33609 
    oprot.writeFieldStop()
33610 
    oprot.writeStructEnd()
33611 
 
33612 
  def validate(self):
33613 
    return
33614 
 
33615 
 
33616 
  def __repr__(self):
33617 
    L = ['%s=%r' % (key, value)
33618 
      for key, value in self.__dict__.iteritems()]
33619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33620 
 
33621 
  def __eq__(self, other):
33622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33623 
 
33624 
  def __ne__(self, other):
33625 
    return not (self == other)
7308 rajveer 33626 
 
33627 
class getAllCircles_args:
33628 
 
33629 
  thrift_spec = (
33630 
  )
33631 
 
33632 
  def read(self, iprot):
33633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33635 
      return
33636 
    iprot.readStructBegin()
33637 
    while True:
33638 
      (fname, ftype, fid) = iprot.readFieldBegin()
33639 
      if ftype == TType.STOP:
33640 
        break
33641 
      else:
33642 
        iprot.skip(ftype)
33643 
      iprot.readFieldEnd()
33644 
    iprot.readStructEnd()
33645 
 
33646 
  def write(self, oprot):
33647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33649 
      return
33650 
    oprot.writeStructBegin('getAllCircles_args')
33651 
    oprot.writeFieldStop()
33652 
    oprot.writeStructEnd()
33653 
 
33654 
  def validate(self):
33655 
    return
33656 
 
33657 
 
33658 
  def __repr__(self):
33659 
    L = ['%s=%r' % (key, value)
33660 
      for key, value in self.__dict__.iteritems()]
33661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33662 
 
33663 
  def __eq__(self, other):
33664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33665 
 
33666 
  def __ne__(self, other):
33667 
    return not (self == other)
33668 
 
33669 
class getAllCircles_result:
33670 
  """
33671 
  Attributes:
33672 
   - success
33673 
  """
33674 
 
33675 
  thrift_spec = (
33676 
    (0, TType.LIST, 'success', (TType.STRUCT,(TelecomCircle, TelecomCircle.thrift_spec)), None, ), # 0
33677 
  )
33678 
 
33679 
  def __init__(self, success=None,):
33680 
    self.success = success
33681 
 
33682 
  def read(self, iprot):
33683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33685 
      return
33686 
    iprot.readStructBegin()
33687 
    while True:
33688 
      (fname, ftype, fid) = iprot.readFieldBegin()
33689 
      if ftype == TType.STOP:
33690 
        break
33691 
      if fid == 0:
33692 
        if ftype == TType.LIST:
33693 
          self.success = []
33694 
          (_etype768, _size765) = iprot.readListBegin()
33695 
          for _i769 in xrange(_size765):
33696 
            _elem770 = TelecomCircle()
33697 
            _elem770.read(iprot)
33698 
            self.success.append(_elem770)
33699 
          iprot.readListEnd()
33700 
        else:
33701 
          iprot.skip(ftype)
33702 
      else:
33703 
        iprot.skip(ftype)
33704 
      iprot.readFieldEnd()
33705 
    iprot.readStructEnd()
33706 
 
33707 
  def write(self, oprot):
33708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33710 
      return
33711 
    oprot.writeStructBegin('getAllCircles_result')
33712 
    if self.success is not None:
33713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
33715 
      for iter771 in self.success:
33716 
        iter771.write(oprot)
33717 
      oprot.writeListEnd()
33718 
      oprot.writeFieldEnd()
33719 
    oprot.writeFieldStop()
33720 
    oprot.writeStructEnd()
33721 
 
33722 
  def validate(self):
33723 
    return
33724 
 
33725 
 
33726 
  def __repr__(self):
33727 
    L = ['%s=%r' % (key, value)
33728 
      for key, value in self.__dict__.iteritems()]
33729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33730 
 
33731 
  def __eq__(self, other):
33732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33733 
 
33734 
  def __ne__(self, other):
33735 
    return not (self == other)
33736 
 
33737 
class deleteFrcs_args:
33738 
  """
33739 
  Attributes:
33740 
   - frcIdsToDelete
33741 
  """
33742 
 
33743 
  thrift_spec = (
33744 
    None, # 0
33745 
    (1, TType.LIST, 'frcIdsToDelete', (TType.I64,None), None, ), # 1
33746 
  )
33747 
 
33748 
  def __init__(self, frcIdsToDelete=None,):
33749 
    self.frcIdsToDelete = frcIdsToDelete
33750 
 
33751 
  def read(self, iprot):
33752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33754 
      return
33755 
    iprot.readStructBegin()
33756 
    while True:
33757 
      (fname, ftype, fid) = iprot.readFieldBegin()
33758 
      if ftype == TType.STOP:
33759 
        break
33760 
      if fid == 1:
33761 
        if ftype == TType.LIST:
33762 
          self.frcIdsToDelete = []
33763 
          (_etype775, _size772) = iprot.readListBegin()
33764 
          for _i776 in xrange(_size772):
33765 
            _elem777 = iprot.readI64();
33766 
            self.frcIdsToDelete.append(_elem777)
33767 
          iprot.readListEnd()
33768 
        else:
33769 
          iprot.skip(ftype)
33770 
      else:
33771 
        iprot.skip(ftype)
33772 
      iprot.readFieldEnd()
33773 
    iprot.readStructEnd()
33774 
 
33775 
  def write(self, oprot):
33776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33778 
      return
33779 
    oprot.writeStructBegin('deleteFrcs_args')
33780 
    if self.frcIdsToDelete is not None:
33781 
      oprot.writeFieldBegin('frcIdsToDelete', TType.LIST, 1)
33782 
      oprot.writeListBegin(TType.I64, len(self.frcIdsToDelete))
33783 
      for iter778 in self.frcIdsToDelete:
33784 
        oprot.writeI64(iter778)
33785 
      oprot.writeListEnd()
33786 
      oprot.writeFieldEnd()
33787 
    oprot.writeFieldStop()
33788 
    oprot.writeStructEnd()
33789 
 
33790 
  def validate(self):
33791 
    return
33792 
 
33793 
 
33794 
  def __repr__(self):
33795 
    L = ['%s=%r' % (key, value)
33796 
      for key, value in self.__dict__.iteritems()]
33797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33798 
 
33799 
  def __eq__(self, other):
33800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33801 
 
33802 
  def __ne__(self, other):
33803 
    return not (self == other)
33804 
 
33805 
class deleteFrcs_result:
33806 
  """
33807 
  Attributes:
33808 
   - success
33809 
  """
33810 
 
33811 
  thrift_spec = (
33812 
    (0, TType.BOOL, 'success', None, None, ), # 0
33813 
  )
33814 
 
33815 
  def __init__(self, success=None,):
33816 
    self.success = success
33817 
 
33818 
  def read(self, iprot):
33819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33821 
      return
33822 
    iprot.readStructBegin()
33823 
    while True:
33824 
      (fname, ftype, fid) = iprot.readFieldBegin()
33825 
      if ftype == TType.STOP:
33826 
        break
33827 
      if fid == 0:
33828 
        if ftype == TType.BOOL:
33829 
          self.success = iprot.readBool();
33830 
        else:
33831 
          iprot.skip(ftype)
33832 
      else:
33833 
        iprot.skip(ftype)
33834 
      iprot.readFieldEnd()
33835 
    iprot.readStructEnd()
33836 
 
33837 
  def write(self, oprot):
33838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33840 
      return
33841 
    oprot.writeStructBegin('deleteFrcs_result')
33842 
    if self.success is not None:
33843 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
33844 
      oprot.writeBool(self.success)
33845 
      oprot.writeFieldEnd()
33846 
    oprot.writeFieldStop()
33847 
    oprot.writeStructEnd()
33848 
 
33849 
  def validate(self):
33850 
    return
33851 
 
33852 
 
33853 
  def __repr__(self):
33854 
    L = ['%s=%r' % (key, value)
33855 
      for key, value in self.__dict__.iteritems()]
33856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33857 
 
33858 
  def __eq__(self, other):
33859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33860 
 
33861 
  def __ne__(self, other):
33862 
    return not (self == other)
7311 kshitij.so 33863 
 
33864 
class addAmazonOrder_args:
33865 
  """
33866 
  Attributes:
33867 
   - amazonOrder
33868 
  """
33869 
 
33870 
  thrift_spec = (
33871 
    None, # 0
33872 
    (1, TType.STRUCT, 'amazonOrder', (AmazonOrder, AmazonOrder.thrift_spec), None, ), # 1
33873 
  )
33874 
 
33875 
  def __init__(self, amazonOrder=None,):
33876 
    self.amazonOrder = amazonOrder
33877 
 
33878 
  def read(self, iprot):
33879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33881 
      return
33882 
    iprot.readStructBegin()
33883 
    while True:
33884 
      (fname, ftype, fid) = iprot.readFieldBegin()
33885 
      if ftype == TType.STOP:
33886 
        break
33887 
      if fid == 1:
33888 
        if ftype == TType.STRUCT:
33889 
          self.amazonOrder = AmazonOrder()
33890 
          self.amazonOrder.read(iprot)
33891 
        else:
33892 
          iprot.skip(ftype)
33893 
      else:
33894 
        iprot.skip(ftype)
33895 
      iprot.readFieldEnd()
33896 
    iprot.readStructEnd()
33897 
 
33898 
  def write(self, oprot):
33899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33901 
      return
33902 
    oprot.writeStructBegin('addAmazonOrder_args')
33903 
    if self.amazonOrder is not None:
33904 
      oprot.writeFieldBegin('amazonOrder', TType.STRUCT, 1)
33905 
      self.amazonOrder.write(oprot)
33906 
      oprot.writeFieldEnd()
33907 
    oprot.writeFieldStop()
33908 
    oprot.writeStructEnd()
33909 
 
33910 
  def validate(self):
33911 
    return
33912 
 
33913 
 
33914 
  def __repr__(self):
33915 
    L = ['%s=%r' % (key, value)
33916 
      for key, value in self.__dict__.iteritems()]
33917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33918 
 
33919 
  def __eq__(self, other):
33920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33921 
 
33922 
  def __ne__(self, other):
33923 
    return not (self == other)
33924 
 
33925 
class addAmazonOrder_result:
33926 
 
33927 
  thrift_spec = (
33928 
  )
33929 
 
33930 
  def read(self, iprot):
33931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33933 
      return
33934 
    iprot.readStructBegin()
33935 
    while True:
33936 
      (fname, ftype, fid) = iprot.readFieldBegin()
33937 
      if ftype == TType.STOP:
33938 
        break
33939 
      else:
33940 
        iprot.skip(ftype)
33941 
      iprot.readFieldEnd()
33942 
    iprot.readStructEnd()
33943 
 
33944 
  def write(self, oprot):
33945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33947 
      return
33948 
    oprot.writeStructBegin('addAmazonOrder_result')
33949 
    oprot.writeFieldStop()
33950 
    oprot.writeStructEnd()
33951 
 
33952 
  def validate(self):
33953 
    return
33954 
 
33955 
 
33956 
  def __repr__(self):
33957 
    L = ['%s=%r' % (key, value)
33958 
      for key, value in self.__dict__.iteritems()]
33959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33960 
 
33961 
  def __eq__(self, other):
33962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33963 
 
33964 
  def __ne__(self, other):
33965 
    return not (self == other)
33966 
 
7322 vikram.rag 33967 
class updateAmazonOrderStatus_args:
7311 kshitij.so 33968 
  """
33969 
  Attributes:
33970 
   - orderId
33971 
   - status
33972 
  """
33973 
 
33974 
  thrift_spec = (
33975 
    None, # 0
33976 
    (1, TType.I64, 'orderId', None, None, ), # 1
33977 
    (2, TType.STRING, 'status', None, None, ), # 2
33978 
  )
33979 
 
33980 
  def __init__(self, orderId=None, status=None,):
33981 
    self.orderId = orderId
33982 
    self.status = status
33983 
 
33984 
  def read(self, iprot):
33985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33987 
      return
33988 
    iprot.readStructBegin()
33989 
    while True:
33990 
      (fname, ftype, fid) = iprot.readFieldBegin()
33991 
      if ftype == TType.STOP:
33992 
        break
33993 
      if fid == 1:
33994 
        if ftype == TType.I64:
33995 
          self.orderId = iprot.readI64();
33996 
        else:
33997 
          iprot.skip(ftype)
33998 
      elif fid == 2:
33999 
        if ftype == TType.STRING:
34000 
          self.status = iprot.readString();
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
7322 vikram.rag 34012 
    oprot.writeStructBegin('updateAmazonOrderStatus_args')
7311 kshitij.so 34013 
    if self.orderId is not None:
34014 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
34015 
      oprot.writeI64(self.orderId)
34016 
      oprot.writeFieldEnd()
34017 
    if self.status is not None:
34018 
      oprot.writeFieldBegin('status', TType.STRING, 2)
34019 
      oprot.writeString(self.status)
34020 
      oprot.writeFieldEnd()
34021 
    oprot.writeFieldStop()
34022 
    oprot.writeStructEnd()
34023 
 
34024 
  def validate(self):
34025 
    return
34026 
 
34027 
 
34028 
  def __repr__(self):
34029 
    L = ['%s=%r' % (key, value)
34030 
      for key, value in self.__dict__.iteritems()]
34031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34032 
 
34033 
  def __eq__(self, other):
34034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34035 
 
34036 
  def __ne__(self, other):
34037 
    return not (self == other)
34038 
 
7322 vikram.rag 34039 
class updateAmazonOrderStatus_result:
7311 kshitij.so 34040 
  """
34041 
  Attributes:
34042 
   - success
34043 
  """
34044 
 
34045 
  thrift_spec = (
34046 
    (0, TType.BOOL, 'success', None, None, ), # 0
34047 
  )
34048 
 
34049 
  def __init__(self, success=None,):
34050 
    self.success = success
34051 
 
34052 
  def read(self, iprot):
34053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34055 
      return
34056 
    iprot.readStructBegin()
34057 
    while True:
34058 
      (fname, ftype, fid) = iprot.readFieldBegin()
34059 
      if ftype == TType.STOP:
34060 
        break
34061 
      if fid == 0:
34062 
        if ftype == TType.BOOL:
34063 
          self.success = iprot.readBool();
34064 
        else:
34065 
          iprot.skip(ftype)
34066 
      else:
34067 
        iprot.skip(ftype)
34068 
      iprot.readFieldEnd()
34069 
    iprot.readStructEnd()
34070 
 
34071 
  def write(self, oprot):
34072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34074 
      return
7322 vikram.rag 34075 
    oprot.writeStructBegin('updateAmazonOrderStatus_result')
7311 kshitij.so 34076 
    if self.success is not None:
34077 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
34078 
      oprot.writeBool(self.success)
34079 
      oprot.writeFieldEnd()
34080 
    oprot.writeFieldStop()
34081 
    oprot.writeStructEnd()
34082 
 
34083 
  def validate(self):
34084 
    return
34085 
 
34086 
 
34087 
  def __repr__(self):
34088 
    L = ['%s=%r' % (key, value)
34089 
      for key, value in self.__dict__.iteritems()]
34090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34091 
 
34092 
  def __eq__(self, other):
34093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34094 
 
34095 
  def __ne__(self, other):
34096 
    return not (self == other)
34097 
 
34098 
class getAmazonOrdersShipped_args:
34099 
  """
34100 
  Attributes:
34101 
   - interval
34102 
  """
34103 
 
34104 
  thrift_spec = (
34105 
    None, # 0
34106 
    (1, TType.I64, 'interval', None, None, ), # 1
34107 
  )
34108 
 
34109 
  def __init__(self, interval=None,):
34110 
    self.interval = interval
34111 
 
34112 
  def read(self, iprot):
34113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34115 
      return
34116 
    iprot.readStructBegin()
34117 
    while True:
34118 
      (fname, ftype, fid) = iprot.readFieldBegin()
34119 
      if ftype == TType.STOP:
34120 
        break
34121 
      if fid == 1:
34122 
        if ftype == TType.I64:
34123 
          self.interval = iprot.readI64();
34124 
        else:
34125 
          iprot.skip(ftype)
34126 
      else:
34127 
        iprot.skip(ftype)
34128 
      iprot.readFieldEnd()
34129 
    iprot.readStructEnd()
34130 
 
34131 
  def write(self, oprot):
34132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34134 
      return
34135 
    oprot.writeStructBegin('getAmazonOrdersShipped_args')
34136 
    if self.interval is not None:
34137 
      oprot.writeFieldBegin('interval', TType.I64, 1)
34138 
      oprot.writeI64(self.interval)
34139 
      oprot.writeFieldEnd()
34140 
    oprot.writeFieldStop()
34141 
    oprot.writeStructEnd()
34142 
 
34143 
  def validate(self):
34144 
    return
34145 
 
34146 
 
34147 
  def __repr__(self):
34148 
    L = ['%s=%r' % (key, value)
34149 
      for key, value in self.__dict__.iteritems()]
34150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34151 
 
34152 
  def __eq__(self, other):
34153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34154 
 
34155 
  def __ne__(self, other):
34156 
    return not (self == other)
34157 
 
34158 
class getAmazonOrdersShipped_result:
34159 
  """
34160 
  Attributes:
34161 
   - success
34162 
  """
34163 
 
34164 
  thrift_spec = (
34165 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
34166 
  )
34167 
 
34168 
  def __init__(self, success=None,):
34169 
    self.success = success
34170 
 
34171 
  def read(self, iprot):
34172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34174 
      return
34175 
    iprot.readStructBegin()
34176 
    while True:
34177 
      (fname, ftype, fid) = iprot.readFieldBegin()
34178 
      if ftype == TType.STOP:
34179 
        break
34180 
      if fid == 0:
34181 
        if ftype == TType.LIST:
34182 
          self.success = []
34183 
          (_etype782, _size779) = iprot.readListBegin()
34184 
          for _i783 in xrange(_size779):
34185 
            _elem784 = Order()
34186 
            _elem784.read(iprot)
34187 
            self.success.append(_elem784)
34188 
          iprot.readListEnd()
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('getAmazonOrdersShipped_result')
34201 
    if self.success is not None:
34202 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34203 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
34204 
      for iter785 in self.success:
34205 
        iter785.write(oprot)
34206 
      oprot.writeListEnd()
34207 
      oprot.writeFieldEnd()
34208 
    oprot.writeFieldStop()
34209 
    oprot.writeStructEnd()
34210 
 
34211 
  def validate(self):
34212 
    return
34213 
 
34214 
 
34215 
  def __repr__(self):
34216 
    L = ['%s=%r' % (key, value)
34217 
      for key, value in self.__dict__.iteritems()]
34218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34219 
 
34220 
  def __eq__(self, other):
34221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34222 
 
34223 
  def __ne__(self, other):
34224 
    return not (self == other)
34225 
 
34226 
class getAmazonOrdersCancelled_args:
34227 
  """
34228 
  Attributes:
34229 
   - interval
34230 
  """
34231 
 
34232 
  thrift_spec = (
34233 
    None, # 0
34234 
    (1, TType.I64, 'interval', None, None, ), # 1
34235 
  )
34236 
 
34237 
  def __init__(self, interval=None,):
34238 
    self.interval = interval
34239 
 
34240 
  def read(self, iprot):
34241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34243 
      return
34244 
    iprot.readStructBegin()
34245 
    while True:
34246 
      (fname, ftype, fid) = iprot.readFieldBegin()
34247 
      if ftype == TType.STOP:
34248 
        break
34249 
      if fid == 1:
34250 
        if ftype == TType.I64:
34251 
          self.interval = iprot.readI64();
34252 
        else:
34253 
          iprot.skip(ftype)
34254 
      else:
34255 
        iprot.skip(ftype)
34256 
      iprot.readFieldEnd()
34257 
    iprot.readStructEnd()
34258 
 
34259 
  def write(self, oprot):
34260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34262 
      return
34263 
    oprot.writeStructBegin('getAmazonOrdersCancelled_args')
34264 
    if self.interval is not None:
34265 
      oprot.writeFieldBegin('interval', TType.I64, 1)
34266 
      oprot.writeI64(self.interval)
34267 
      oprot.writeFieldEnd()
34268 
    oprot.writeFieldStop()
34269 
    oprot.writeStructEnd()
34270 
 
34271 
  def validate(self):
34272 
    return
34273 
 
34274 
 
34275 
  def __repr__(self):
34276 
    L = ['%s=%r' % (key, value)
34277 
      for key, value in self.__dict__.iteritems()]
34278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34279 
 
34280 
  def __eq__(self, other):
34281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34282 
 
34283 
  def __ne__(self, other):
34284 
    return not (self == other)
34285 
 
34286 
class getAmazonOrdersCancelled_result:
34287 
  """
34288 
  Attributes:
34289 
   - success
34290 
  """
34291 
 
34292 
  thrift_spec = (
34293 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
34294 
  )
34295 
 
34296 
  def __init__(self, success=None,):
34297 
    self.success = success
34298 
 
34299 
  def read(self, iprot):
34300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34302 
      return
34303 
    iprot.readStructBegin()
34304 
    while True:
34305 
      (fname, ftype, fid) = iprot.readFieldBegin()
34306 
      if ftype == TType.STOP:
34307 
        break
34308 
      if fid == 0:
34309 
        if ftype == TType.LIST:
34310 
          self.success = []
34311 
          (_etype789, _size786) = iprot.readListBegin()
34312 
          for _i790 in xrange(_size786):
34313 
            _elem791 = Order()
34314 
            _elem791.read(iprot)
34315 
            self.success.append(_elem791)
34316 
          iprot.readListEnd()
34317 
        else:
34318 
          iprot.skip(ftype)
34319 
      else:
34320 
        iprot.skip(ftype)
34321 
      iprot.readFieldEnd()
34322 
    iprot.readStructEnd()
34323 
 
34324 
  def write(self, oprot):
34325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34327 
      return
34328 
    oprot.writeStructBegin('getAmazonOrdersCancelled_result')
34329 
    if self.success is not None:
34330 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34331 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
34332 
      for iter792 in self.success:
34333 
        iter792.write(oprot)
34334 
      oprot.writeListEnd()
34335 
      oprot.writeFieldEnd()
34336 
    oprot.writeFieldStop()
34337 
    oprot.writeStructEnd()
34338 
 
34339 
  def validate(self):
34340 
    return
34341 
 
34342 
 
34343 
  def __repr__(self):
34344 
    L = ['%s=%r' % (key, value)
34345 
      for key, value in self.__dict__.iteritems()]
34346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34347 
 
34348 
  def __eq__(self, other):
34349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34350 
 
34351 
  def __ne__(self, other):
34352 
    return not (self == other)
7322 vikram.rag 34353 
 
34354 
class getAmazonOrder_args:
34355 
  """
34356 
  Attributes:
34357 
   - orderId
34358 
  """
34359 
 
34360 
  thrift_spec = (
34361 
    None, # 0
34362 
    (1, TType.I64, 'orderId', None, None, ), # 1
34363 
  )
34364 
 
34365 
  def __init__(self, orderId=None,):
34366 
    self.orderId = orderId
34367 
 
34368 
  def read(self, iprot):
34369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34371 
      return
34372 
    iprot.readStructBegin()
34373 
    while True:
34374 
      (fname, ftype, fid) = iprot.readFieldBegin()
34375 
      if ftype == TType.STOP:
34376 
        break
34377 
      if fid == 1:
34378 
        if ftype == TType.I64:
34379 
          self.orderId = iprot.readI64();
34380 
        else:
34381 
          iprot.skip(ftype)
34382 
      else:
34383 
        iprot.skip(ftype)
34384 
      iprot.readFieldEnd()
34385 
    iprot.readStructEnd()
34386 
 
34387 
  def write(self, oprot):
34388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34390 
      return
34391 
    oprot.writeStructBegin('getAmazonOrder_args')
34392 
    if self.orderId is not None:
34393 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
34394 
      oprot.writeI64(self.orderId)
34395 
      oprot.writeFieldEnd()
34396 
    oprot.writeFieldStop()
34397 
    oprot.writeStructEnd()
34398 
 
34399 
  def validate(self):
34400 
    return
34401 
 
34402 
 
34403 
  def __repr__(self):
34404 
    L = ['%s=%r' % (key, value)
34405 
      for key, value in self.__dict__.iteritems()]
34406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34407 
 
34408 
  def __eq__(self, other):
34409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34410 
 
34411 
  def __ne__(self, other):
34412 
    return not (self == other)
34413 
 
34414 
class getAmazonOrder_result:
34415 
  """
34416 
  Attributes:
34417 
   - success
34418 
  """
34419 
 
34420 
  thrift_spec = (
34421 
    (0, TType.STRUCT, 'success', (AmazonOrder, AmazonOrder.thrift_spec), None, ), # 0
34422 
  )
34423 
 
34424 
  def __init__(self, success=None,):
34425 
    self.success = success
34426 
 
34427 
  def read(self, iprot):
34428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34430 
      return
34431 
    iprot.readStructBegin()
34432 
    while True:
34433 
      (fname, ftype, fid) = iprot.readFieldBegin()
34434 
      if ftype == TType.STOP:
34435 
        break
34436 
      if fid == 0:
34437 
        if ftype == TType.STRUCT:
34438 
          self.success = AmazonOrder()
34439 
          self.success.read(iprot)
34440 
        else:
34441 
          iprot.skip(ftype)
34442 
      else:
34443 
        iprot.skip(ftype)
34444 
      iprot.readFieldEnd()
34445 
    iprot.readStructEnd()
34446 
 
34447 
  def write(self, oprot):
34448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34450 
      return
34451 
    oprot.writeStructBegin('getAmazonOrder_result')
34452 
    if self.success is not None:
34453 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
34454 
      self.success.write(oprot)
34455 
      oprot.writeFieldEnd()
34456 
    oprot.writeFieldStop()
34457 
    oprot.writeStructEnd()
34458 
 
34459 
  def validate(self):
34460 
    return
34461 
 
34462 
 
34463 
  def __repr__(self):
34464 
    L = ['%s=%r' % (key, value)
34465 
      for key, value in self.__dict__.iteritems()]
34466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34467 
 
34468 
  def __eq__(self, other):
34469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34470 
 
34471 
  def __ne__(self, other):
34472 
    return not (self == other)
7343 anupam.sin 34473 
 
34474 
class getOrdersForStore_args:
34475 
  """
34476 
  Attributes:
34477 
   - id
34478 
   - storeId
34479 
   - startDate
34480 
   - endDate
34481 
   - statuses
34482 
  """
34483 
 
34484 
  thrift_spec = (
34485 
    None, # 0
34486 
    (1, TType.I64, 'id', None, None, ), # 1
34487 
    (2, TType.I64, 'storeId', None, None, ), # 2
34488 
    (3, TType.I64, 'startDate', None, None, ), # 3
34489 
    (4, TType.I64, 'endDate', None, None, ), # 4
34490 
    (5, TType.LIST, 'statuses', (TType.I32,None), None, ), # 5
34491 
  )
34492 
 
34493 
  def __init__(self, id=None, storeId=None, startDate=None, endDate=None, statuses=None,):
34494 
    self.id = id
34495 
    self.storeId = storeId
34496 
    self.startDate = startDate
34497 
    self.endDate = endDate
34498 
    self.statuses = statuses
34499 
 
34500 
  def read(self, iprot):
34501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34503 
      return
34504 
    iprot.readStructBegin()
34505 
    while True:
34506 
      (fname, ftype, fid) = iprot.readFieldBegin()
34507 
      if ftype == TType.STOP:
34508 
        break
34509 
      if fid == 1:
34510 
        if ftype == TType.I64:
34511 
          self.id = iprot.readI64();
34512 
        else:
34513 
          iprot.skip(ftype)
34514 
      elif fid == 2:
34515 
        if ftype == TType.I64:
34516 
          self.storeId = iprot.readI64();
34517 
        else:
34518 
          iprot.skip(ftype)
34519 
      elif fid == 3:
34520 
        if ftype == TType.I64:
34521 
          self.startDate = iprot.readI64();
34522 
        else:
34523 
          iprot.skip(ftype)
34524 
      elif fid == 4:
34525 
        if ftype == TType.I64:
34526 
          self.endDate = iprot.readI64();
34527 
        else:
34528 
          iprot.skip(ftype)
34529 
      elif fid == 5:
34530 
        if ftype == TType.LIST:
34531 
          self.statuses = []
34532 
          (_etype796, _size793) = iprot.readListBegin()
34533 
          for _i797 in xrange(_size793):
34534 
            _elem798 = iprot.readI32();
34535 
            self.statuses.append(_elem798)
34536 
          iprot.readListEnd()
34537 
        else:
34538 
          iprot.skip(ftype)
34539 
      else:
34540 
        iprot.skip(ftype)
34541 
      iprot.readFieldEnd()
34542 
    iprot.readStructEnd()
34543 
 
34544 
  def write(self, oprot):
34545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34547 
      return
34548 
    oprot.writeStructBegin('getOrdersForStore_args')
34549 
    if self.id is not None:
34550 
      oprot.writeFieldBegin('id', TType.I64, 1)
34551 
      oprot.writeI64(self.id)
34552 
      oprot.writeFieldEnd()
34553 
    if self.storeId is not None:
34554 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
34555 
      oprot.writeI64(self.storeId)
34556 
      oprot.writeFieldEnd()
34557 
    if self.startDate is not None:
34558 
      oprot.writeFieldBegin('startDate', TType.I64, 3)
34559 
      oprot.writeI64(self.startDate)
34560 
      oprot.writeFieldEnd()
34561 
    if self.endDate is not None:
34562 
      oprot.writeFieldBegin('endDate', TType.I64, 4)
34563 
      oprot.writeI64(self.endDate)
34564 
      oprot.writeFieldEnd()
34565 
    if self.statuses is not None:
34566 
      oprot.writeFieldBegin('statuses', TType.LIST, 5)
34567 
      oprot.writeListBegin(TType.I32, len(self.statuses))
34568 
      for iter799 in self.statuses:
34569 
        oprot.writeI32(iter799)
34570 
      oprot.writeListEnd()
34571 
      oprot.writeFieldEnd()
34572 
    oprot.writeFieldStop()
34573 
    oprot.writeStructEnd()
34574 
 
34575 
  def validate(self):
34576 
    return
34577 
 
34578 
 
34579 
  def __repr__(self):
34580 
    L = ['%s=%r' % (key, value)
34581 
      for key, value in self.__dict__.iteritems()]
34582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34583 
 
34584 
  def __eq__(self, other):
34585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34586 
 
34587 
  def __ne__(self, other):
34588 
    return not (self == other)
34589 
 
34590 
class getOrdersForStore_result:
34591 
  """
34592 
  Attributes:
34593 
   - success
34594 
  """
34595 
 
34596 
  thrift_spec = (
34597 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
34598 
  )
34599 
 
34600 
  def __init__(self, success=None,):
34601 
    self.success = success
34602 
 
34603 
  def read(self, iprot):
34604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34606 
      return
34607 
    iprot.readStructBegin()
34608 
    while True:
34609 
      (fname, ftype, fid) = iprot.readFieldBegin()
34610 
      if ftype == TType.STOP:
34611 
        break
34612 
      if fid == 0:
34613 
        if ftype == TType.LIST:
34614 
          self.success = []
34615 
          (_etype803, _size800) = iprot.readListBegin()
34616 
          for _i804 in xrange(_size800):
34617 
            _elem805 = Order()
34618 
            _elem805.read(iprot)
34619 
            self.success.append(_elem805)
34620 
          iprot.readListEnd()
34621 
        else:
34622 
          iprot.skip(ftype)
34623 
      else:
34624 
        iprot.skip(ftype)
34625 
      iprot.readFieldEnd()
34626 
    iprot.readStructEnd()
34627 
 
34628 
  def write(self, oprot):
34629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34631 
      return
34632 
    oprot.writeStructBegin('getOrdersForStore_result')
34633 
    if self.success is not None:
34634 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34635 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
34636 
      for iter806 in self.success:
34637 
        iter806.write(oprot)
34638 
      oprot.writeListEnd()
34639 
      oprot.writeFieldEnd()
34640 
    oprot.writeFieldStop()
34641 
    oprot.writeStructEnd()
34642 
 
34643 
  def validate(self):
34644 
    return
34645 
 
34646 
 
34647 
  def __repr__(self):
34648 
    L = ['%s=%r' % (key, value)
34649 
      for key, value in self.__dict__.iteritems()]
34650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34651 
 
34652 
  def __eq__(self, other):
34653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34654 
 
34655 
  def __ne__(self, other):
34656 
    return not (self == other)
34657 
 
34658 
class getStoreOrderAdvanceInvoice_args:
34659 
  """
34660 
  Attributes:
34661 
   - orderId
34662 
  """
34663 
 
34664 
  thrift_spec = (
34665 
    None, # 0
34666 
    (1, TType.I64, 'orderId', None, None, ), # 1
34667 
  )
34668 
 
34669 
  def __init__(self, orderId=None,):
34670 
    self.orderId = orderId
34671 
 
34672 
  def read(self, iprot):
34673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34675 
      return
34676 
    iprot.readStructBegin()
34677 
    while True:
34678 
      (fname, ftype, fid) = iprot.readFieldBegin()
34679 
      if ftype == TType.STOP:
34680 
        break
34681 
      if fid == 1:
34682 
        if ftype == TType.I64:
34683 
          self.orderId = iprot.readI64();
34684 
        else:
34685 
          iprot.skip(ftype)
34686 
      else:
34687 
        iprot.skip(ftype)
34688 
      iprot.readFieldEnd()
34689 
    iprot.readStructEnd()
34690 
 
34691 
  def write(self, oprot):
34692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34694 
      return
34695 
    oprot.writeStructBegin('getStoreOrderAdvanceInvoice_args')
34696 
    if self.orderId is not None:
34697 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
34698 
      oprot.writeI64(self.orderId)
34699 
      oprot.writeFieldEnd()
34700 
    oprot.writeFieldStop()
34701 
    oprot.writeStructEnd()
34702 
 
34703 
  def validate(self):
34704 
    return
34705 
 
34706 
 
34707 
  def __repr__(self):
34708 
    L = ['%s=%r' % (key, value)
34709 
      for key, value in self.__dict__.iteritems()]
34710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34711 
 
34712 
  def __eq__(self, other):
34713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34714 
 
34715 
  def __ne__(self, other):
34716 
    return not (self == other)
34717 
 
34718 
class getStoreOrderAdvanceInvoice_result:
34719 
  """
34720 
  Attributes:
34721 
   - success
34722 
  """
34723 
 
34724 
  thrift_spec = (
34725 
    (0, TType.STRING, 'success', None, None, ), # 0
34726 
  )
34727 
 
34728 
  def __init__(self, success=None,):
34729 
    self.success = success
34730 
 
34731 
  def read(self, iprot):
34732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34734 
      return
34735 
    iprot.readStructBegin()
34736 
    while True:
34737 
      (fname, ftype, fid) = iprot.readFieldBegin()
34738 
      if ftype == TType.STOP:
34739 
        break
34740 
      if fid == 0:
34741 
        if ftype == TType.STRING:
34742 
          self.success = iprot.readString();
34743 
        else:
34744 
          iprot.skip(ftype)
34745 
      else:
34746 
        iprot.skip(ftype)
34747 
      iprot.readFieldEnd()
34748 
    iprot.readStructEnd()
34749 
 
34750 
  def write(self, oprot):
34751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34753 
      return
34754 
    oprot.writeStructBegin('getStoreOrderAdvanceInvoice_result')
34755 
    if self.success is not None:
34756 
      oprot.writeFieldBegin('success', TType.STRING, 0)
34757 
      oprot.writeString(self.success)
34758 
      oprot.writeFieldEnd()
34759 
    oprot.writeFieldStop()
34760 
    oprot.writeStructEnd()
34761 
 
34762 
  def validate(self):
34763 
    return
34764 
 
34765 
 
34766 
  def __repr__(self):
34767 
    L = ['%s=%r' % (key, value)
34768 
      for key, value in self.__dict__.iteritems()]
34769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34770 
 
34771 
  def __eq__(self, other):
34772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34773 
 
34774 
  def __ne__(self, other):
34775 
    return not (self == other)